docusign_esign.apis.accounts_api
DocuSign REST API
The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign. # noqa: E501
OpenAPI spec version: v2.1 Contact: devcenter@docusign.com Generated by: https://github.com/swagger-api/swagger-codegen.git
1# coding: utf-8 2 3""" 4 DocuSign REST API 5 6 The DocuSign REST API provides you with a powerful, convenient, and simple Web services API for interacting with DocuSign. # noqa: E501 7 8 OpenAPI spec version: v2.1 9 Contact: devcenter@docusign.com 10 Generated by: https://github.com/swagger-api/swagger-codegen.git 11""" 12 13 14from __future__ import absolute_import 15 16import sys 17import os 18import re 19 20# python 2 and python 3 compatibility library 21from six import iteritems 22 23from ..client.configuration import Configuration 24from ..client.api_client import ApiClient 25 26 27class AccountsApi(object): 28 """ 29 NOTE: This class is auto generated by the swagger code generator program. 30 Do not edit the class manually. 31 Ref: https://github.com/swagger-api/swagger-codegen 32 """ 33 34 def __init__(self, api_client=None): 35 config = Configuration() 36 if api_client: 37 self.api_client = api_client 38 else: 39 if not config.api_client: 40 config.api_client = ApiClient() 41 self.api_client = config.api_client 42 43 def create(self, **kwargs): 44 """ 45 Creates new accounts. 46 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 47 This method makes a synchronous HTTP request by default. To make an 48 asynchronous HTTP request, please define a `callback` function 49 to be invoked when receiving the response. 50 >>> def callback_function(response): 51 >>> pprint(response) 52 >>> 53 >>> thread = api.create(callback=callback_function) 54 55 :param callback function: The callback function 56 for asynchronous request. (optional) 57 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 58 :param NewAccountDefinition new_account_definition: 59 :return: NewAccountSummary 60 If the method is called asynchronously, 61 returns the request thread. 62 """ 63 kwargs['_return_http_data_only'] = True 64 if kwargs.get('callback'): 65 return self.create_with_http_info(**kwargs) 66 else: 67 (data) = self.create_with_http_info(**kwargs) 68 return data 69 70 def create_with_http_info(self, **kwargs): 71 """ 72 Creates new accounts. 73 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 74 This method makes a synchronous HTTP request by default. To make an 75 asynchronous HTTP request, please define a `callback` function 76 to be invoked when receiving the response. 77 >>> def callback_function(response): 78 >>> pprint(response) 79 >>> 80 >>> thread = api.create_with_http_info(callback=callback_function) 81 82 :param callback function: The callback function 83 for asynchronous request. (optional) 84 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 85 :param NewAccountDefinition new_account_definition: 86 :return: NewAccountSummary 87 If the method is called asynchronously, 88 returns the request thread. 89 """ 90 91 all_params = ['preview_billing_plan', 'new_account_definition'] 92 all_params.append('callback') 93 all_params.append('_return_http_data_only') 94 all_params.append('_preload_content') 95 all_params.append('_request_timeout') 96 97 params = locals() 98 for key, val in iteritems(params['kwargs']): 99 if key not in all_params: 100 raise TypeError( 101 "Got an unexpected keyword argument '%s'" 102 " to method create" % key 103 ) 104 params[key] = val 105 del params['kwargs'] 106 107 108 collection_formats = {} 109 110 resource_path = '/v2.1/accounts'.replace('{format}', 'json') 111 path_params = {} 112 113 query_params = {} 114 if 'preview_billing_plan' in params: 115 query_params['preview_billing_plan'] = params['preview_billing_plan'] 116 117 header_params = {} 118 119 form_params = [] 120 local_var_files = {} 121 122 body_params = None 123 if 'new_account_definition' in params: 124 body_params = params['new_account_definition'] 125 # HTTP header `Accept` 126 header_params['Accept'] = self.api_client.\ 127 select_header_accept(['application/json']) 128 129 # Authentication setting 130 auth_settings = [] 131 132 return self.api_client.call_api(resource_path, 'POST', 133 path_params, 134 query_params, 135 header_params, 136 body=body_params, 137 post_params=form_params, 138 files=local_var_files, 139 response_type='NewAccountSummary', 140 auth_settings=auth_settings, 141 callback=params.get('callback'), 142 _return_http_data_only=params.get('_return_http_data_only'), 143 _preload_content=params.get('_preload_content', True), 144 _request_timeout=params.get('_request_timeout'), 145 collection_formats=collection_formats) 146 147 def create_account_signatures(self, account_id, **kwargs): 148 """ 149 Adds/updates one or more account signatures. This request may include images in multi-part format. 150 151 This method makes a synchronous HTTP request by default. To make an 152 asynchronous HTTP request, please define a `callback` function 153 to be invoked when receiving the response. 154 >>> def callback_function(response): 155 >>> pprint(response) 156 >>> 157 >>> thread = api.create_account_signatures(account_id, callback=callback_function) 158 159 :param callback function: The callback function 160 for asynchronous request. (optional) 161 :param str account_id: The external account number (int) or account ID Guid. (required) 162 :param str decode_only: 163 :param AccountSignaturesInformation account_signatures_information: 164 :return: AccountSignaturesInformation 165 If the method is called asynchronously, 166 returns the request thread. 167 """ 168 kwargs['_return_http_data_only'] = True 169 if kwargs.get('callback'): 170 return self.create_account_signatures_with_http_info(account_id, **kwargs) 171 else: 172 (data) = self.create_account_signatures_with_http_info(account_id, **kwargs) 173 return data 174 175 def create_account_signatures_with_http_info(self, account_id, **kwargs): 176 """ 177 Adds/updates one or more account signatures. This request may include images in multi-part format. 178 179 This method makes a synchronous HTTP request by default. To make an 180 asynchronous HTTP request, please define a `callback` function 181 to be invoked when receiving the response. 182 >>> def callback_function(response): 183 >>> pprint(response) 184 >>> 185 >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function) 186 187 :param callback function: The callback function 188 for asynchronous request. (optional) 189 :param str account_id: The external account number (int) or account ID Guid. (required) 190 :param str decode_only: 191 :param AccountSignaturesInformation account_signatures_information: 192 :return: AccountSignaturesInformation 193 If the method is called asynchronously, 194 returns the request thread. 195 """ 196 197 all_params = ['account_id', 'decode_only', 'account_signatures_information'] 198 all_params.append('callback') 199 all_params.append('_return_http_data_only') 200 all_params.append('_preload_content') 201 all_params.append('_request_timeout') 202 203 params = locals() 204 for key, val in iteritems(params['kwargs']): 205 if key not in all_params: 206 raise TypeError( 207 "Got an unexpected keyword argument '%s'" 208 " to method create_account_signatures" % key 209 ) 210 params[key] = val 211 del params['kwargs'] 212 # verify the required parameter 'account_id' is set 213 if ('account_id' not in params) or (params['account_id'] is None): 214 raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`") 215 216 217 collection_formats = {} 218 219 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 220 path_params = {} 221 if 'account_id' in params: 222 path_params['accountId'] = params['account_id'] 223 224 query_params = {} 225 if 'decode_only' in params: 226 query_params['decode_only'] = params['decode_only'] 227 228 header_params = {} 229 230 form_params = [] 231 local_var_files = {} 232 233 body_params = None 234 if 'account_signatures_information' in params: 235 body_params = params['account_signatures_information'] 236 # HTTP header `Accept` 237 header_params['Accept'] = self.api_client.\ 238 select_header_accept(['application/json']) 239 240 # Authentication setting 241 auth_settings = [] 242 243 return self.api_client.call_api(resource_path, 'POST', 244 path_params, 245 query_params, 246 header_params, 247 body=body_params, 248 post_params=form_params, 249 files=local_var_files, 250 response_type='AccountSignaturesInformation', 251 auth_settings=auth_settings, 252 callback=params.get('callback'), 253 _return_http_data_only=params.get('_return_http_data_only'), 254 _preload_content=params.get('_preload_content', True), 255 _request_timeout=params.get('_request_timeout'), 256 collection_formats=collection_formats) 257 258 def create_brand(self, account_id, **kwargs): 259 """ 260 Creates one or more brand profile files for the account. 261 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 262 This method makes a synchronous HTTP request by default. To make an 263 asynchronous HTTP request, please define a `callback` function 264 to be invoked when receiving the response. 265 >>> def callback_function(response): 266 >>> pprint(response) 267 >>> 268 >>> thread = api.create_brand(account_id, callback=callback_function) 269 270 :param callback function: The callback function 271 for asynchronous request. (optional) 272 :param str account_id: The external account number (int) or account ID GUID. (required) 273 :param Brand brand: 274 :return: BrandsResponse 275 If the method is called asynchronously, 276 returns the request thread. 277 """ 278 kwargs['_return_http_data_only'] = True 279 if kwargs.get('callback'): 280 return self.create_brand_with_http_info(account_id, **kwargs) 281 else: 282 (data) = self.create_brand_with_http_info(account_id, **kwargs) 283 return data 284 285 def create_brand_with_http_info(self, account_id, **kwargs): 286 """ 287 Creates one or more brand profile files for the account. 288 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 289 This method makes a synchronous HTTP request by default. To make an 290 asynchronous HTTP request, please define a `callback` function 291 to be invoked when receiving the response. 292 >>> def callback_function(response): 293 >>> pprint(response) 294 >>> 295 >>> thread = api.create_brand_with_http_info(account_id, callback=callback_function) 296 297 :param callback function: The callback function 298 for asynchronous request. (optional) 299 :param str account_id: The external account number (int) or account ID GUID. (required) 300 :param Brand brand: 301 :return: BrandsResponse 302 If the method is called asynchronously, 303 returns the request thread. 304 """ 305 306 all_params = ['account_id', 'brand'] 307 all_params.append('callback') 308 all_params.append('_return_http_data_only') 309 all_params.append('_preload_content') 310 all_params.append('_request_timeout') 311 312 params = locals() 313 for key, val in iteritems(params['kwargs']): 314 if key not in all_params: 315 raise TypeError( 316 "Got an unexpected keyword argument '%s'" 317 " to method create_brand" % key 318 ) 319 params[key] = val 320 del params['kwargs'] 321 # verify the required parameter 'account_id' is set 322 if ('account_id' not in params) or (params['account_id'] is None): 323 raise ValueError("Missing the required parameter `account_id` when calling `create_brand`") 324 325 326 collection_formats = {} 327 328 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 329 path_params = {} 330 if 'account_id' in params: 331 path_params['accountId'] = params['account_id'] 332 333 query_params = {} 334 335 header_params = {} 336 337 form_params = [] 338 local_var_files = {} 339 340 body_params = None 341 if 'brand' in params: 342 body_params = params['brand'] 343 # HTTP header `Accept` 344 header_params['Accept'] = self.api_client.\ 345 select_header_accept(['application/json']) 346 347 # Authentication setting 348 auth_settings = [] 349 350 return self.api_client.call_api(resource_path, 'POST', 351 path_params, 352 query_params, 353 header_params, 354 body=body_params, 355 post_params=form_params, 356 files=local_var_files, 357 response_type='BrandsResponse', 358 auth_settings=auth_settings, 359 callback=params.get('callback'), 360 _return_http_data_only=params.get('_return_http_data_only'), 361 _preload_content=params.get('_preload_content', True), 362 _request_timeout=params.get('_request_timeout'), 363 collection_formats=collection_formats) 364 365 def create_custom_field(self, account_id, **kwargs): 366 """ 367 Creates an acount custom field. 368 This method creates a custom field and makes it available for all new envelopes associated with an account. 369 This method makes a synchronous HTTP request by default. To make an 370 asynchronous HTTP request, please define a `callback` function 371 to be invoked when receiving the response. 372 >>> def callback_function(response): 373 >>> pprint(response) 374 >>> 375 >>> thread = api.create_custom_field(account_id, callback=callback_function) 376 377 :param callback function: The callback function 378 for asynchronous request. (optional) 379 :param str account_id: The external account number (int) or account ID Guid. (required) 380 :param str apply_to_templates: 381 :param CustomField custom_field: 382 :return: CustomFields 383 If the method is called asynchronously, 384 returns the request thread. 385 """ 386 kwargs['_return_http_data_only'] = True 387 if kwargs.get('callback'): 388 return self.create_custom_field_with_http_info(account_id, **kwargs) 389 else: 390 (data) = self.create_custom_field_with_http_info(account_id, **kwargs) 391 return data 392 393 def create_custom_field_with_http_info(self, account_id, **kwargs): 394 """ 395 Creates an acount custom field. 396 This method creates a custom field and makes it available for all new envelopes associated with an account. 397 This method makes a synchronous HTTP request by default. To make an 398 asynchronous HTTP request, please define a `callback` function 399 to be invoked when receiving the response. 400 >>> def callback_function(response): 401 >>> pprint(response) 402 >>> 403 >>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function) 404 405 :param callback function: The callback function 406 for asynchronous request. (optional) 407 :param str account_id: The external account number (int) or account ID Guid. (required) 408 :param str apply_to_templates: 409 :param CustomField custom_field: 410 :return: CustomFields 411 If the method is called asynchronously, 412 returns the request thread. 413 """ 414 415 all_params = ['account_id', 'apply_to_templates', 'custom_field'] 416 all_params.append('callback') 417 all_params.append('_return_http_data_only') 418 all_params.append('_preload_content') 419 all_params.append('_request_timeout') 420 421 params = locals() 422 for key, val in iteritems(params['kwargs']): 423 if key not in all_params: 424 raise TypeError( 425 "Got an unexpected keyword argument '%s'" 426 " to method create_custom_field" % key 427 ) 428 params[key] = val 429 del params['kwargs'] 430 # verify the required parameter 'account_id' is set 431 if ('account_id' not in params) or (params['account_id'] is None): 432 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`") 433 434 435 collection_formats = {} 436 437 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 438 path_params = {} 439 if 'account_id' in params: 440 path_params['accountId'] = params['account_id'] 441 442 query_params = {} 443 if 'apply_to_templates' in params: 444 query_params['apply_to_templates'] = params['apply_to_templates'] 445 446 header_params = {} 447 448 form_params = [] 449 local_var_files = {} 450 451 body_params = None 452 if 'custom_field' in params: 453 body_params = params['custom_field'] 454 # HTTP header `Accept` 455 header_params['Accept'] = self.api_client.\ 456 select_header_accept(['application/json']) 457 458 # Authentication setting 459 auth_settings = [] 460 461 return self.api_client.call_api(resource_path, 'POST', 462 path_params, 463 query_params, 464 header_params, 465 body=body_params, 466 post_params=form_params, 467 files=local_var_files, 468 response_type='CustomFields', 469 auth_settings=auth_settings, 470 callback=params.get('callback'), 471 _return_http_data_only=params.get('_return_http_data_only'), 472 _preload_content=params.get('_preload_content', True), 473 _request_timeout=params.get('_request_timeout'), 474 collection_formats=collection_formats) 475 476 def create_permission_profile(self, account_id, **kwargs): 477 """ 478 Creates a new permission profile in the specified account. 479 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 480 This method makes a synchronous HTTP request by default. To make an 481 asynchronous HTTP request, please define a `callback` function 482 to be invoked when receiving the response. 483 >>> def callback_function(response): 484 >>> pprint(response) 485 >>> 486 >>> thread = api.create_permission_profile(account_id, callback=callback_function) 487 488 :param callback function: The callback function 489 for asynchronous request. (optional) 490 :param str account_id: The external account number (int) or account ID Guid. (required) 491 :param str include: 492 :param PermissionProfile permission_profile: 493 :return: PermissionProfile 494 If the method is called asynchronously, 495 returns the request thread. 496 """ 497 kwargs['_return_http_data_only'] = True 498 if kwargs.get('callback'): 499 return self.create_permission_profile_with_http_info(account_id, **kwargs) 500 else: 501 (data) = self.create_permission_profile_with_http_info(account_id, **kwargs) 502 return data 503 504 def create_permission_profile_with_http_info(self, account_id, **kwargs): 505 """ 506 Creates a new permission profile in the specified account. 507 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 508 This method makes a synchronous HTTP request by default. To make an 509 asynchronous HTTP request, please define a `callback` function 510 to be invoked when receiving the response. 511 >>> def callback_function(response): 512 >>> pprint(response) 513 >>> 514 >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function) 515 516 :param callback function: The callback function 517 for asynchronous request. (optional) 518 :param str account_id: The external account number (int) or account ID Guid. (required) 519 :param str include: 520 :param PermissionProfile permission_profile: 521 :return: PermissionProfile 522 If the method is called asynchronously, 523 returns the request thread. 524 """ 525 526 all_params = ['account_id', 'include', 'permission_profile'] 527 all_params.append('callback') 528 all_params.append('_return_http_data_only') 529 all_params.append('_preload_content') 530 all_params.append('_request_timeout') 531 532 params = locals() 533 for key, val in iteritems(params['kwargs']): 534 if key not in all_params: 535 raise TypeError( 536 "Got an unexpected keyword argument '%s'" 537 " to method create_permission_profile" % key 538 ) 539 params[key] = val 540 del params['kwargs'] 541 # verify the required parameter 'account_id' is set 542 if ('account_id' not in params) or (params['account_id'] is None): 543 raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`") 544 545 546 collection_formats = {} 547 548 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 549 path_params = {} 550 if 'account_id' in params: 551 path_params['accountId'] = params['account_id'] 552 553 query_params = {} 554 if 'include' in params: 555 query_params['include'] = params['include'] 556 557 header_params = {} 558 559 form_params = [] 560 local_var_files = {} 561 562 body_params = None 563 if 'permission_profile' in params: 564 body_params = params['permission_profile'] 565 # HTTP header `Accept` 566 header_params['Accept'] = self.api_client.\ 567 select_header_accept(['application/json']) 568 569 # Authentication setting 570 auth_settings = [] 571 572 return self.api_client.call_api(resource_path, 'POST', 573 path_params, 574 query_params, 575 header_params, 576 body=body_params, 577 post_params=form_params, 578 files=local_var_files, 579 response_type='PermissionProfile', 580 auth_settings=auth_settings, 581 callback=params.get('callback'), 582 _return_http_data_only=params.get('_return_http_data_only'), 583 _preload_content=params.get('_preload_content', True), 584 _request_timeout=params.get('_request_timeout'), 585 collection_formats=collection_formats) 586 587 def delete(self, account_id, **kwargs): 588 """ 589 Deletes the specified account. 590 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 591 This method makes a synchronous HTTP request by default. To make an 592 asynchronous HTTP request, please define a `callback` function 593 to be invoked when receiving the response. 594 >>> def callback_function(response): 595 >>> pprint(response) 596 >>> 597 >>> thread = api.delete(account_id, callback=callback_function) 598 599 :param callback function: The callback function 600 for asynchronous request. (optional) 601 :param str account_id: The external account number (int) or account ID Guid. (required) 602 :return: None 603 If the method is called asynchronously, 604 returns the request thread. 605 """ 606 kwargs['_return_http_data_only'] = True 607 if kwargs.get('callback'): 608 return self.delete_with_http_info(account_id, **kwargs) 609 else: 610 (data) = self.delete_with_http_info(account_id, **kwargs) 611 return data 612 613 def delete_with_http_info(self, account_id, **kwargs): 614 """ 615 Deletes the specified account. 616 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 617 This method makes a synchronous HTTP request by default. To make an 618 asynchronous HTTP request, please define a `callback` function 619 to be invoked when receiving the response. 620 >>> def callback_function(response): 621 >>> pprint(response) 622 >>> 623 >>> thread = api.delete_with_http_info(account_id, callback=callback_function) 624 625 :param callback function: The callback function 626 for asynchronous request. (optional) 627 :param str account_id: The external account number (int) or account ID Guid. (required) 628 :return: None 629 If the method is called asynchronously, 630 returns the request thread. 631 """ 632 633 all_params = ['account_id'] 634 all_params.append('callback') 635 all_params.append('_return_http_data_only') 636 all_params.append('_preload_content') 637 all_params.append('_request_timeout') 638 639 params = locals() 640 for key, val in iteritems(params['kwargs']): 641 if key not in all_params: 642 raise TypeError( 643 "Got an unexpected keyword argument '%s'" 644 " to method delete" % key 645 ) 646 params[key] = val 647 del params['kwargs'] 648 # verify the required parameter 'account_id' is set 649 if ('account_id' not in params) or (params['account_id'] is None): 650 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 651 652 653 collection_formats = {} 654 655 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 656 path_params = {} 657 if 'account_id' in params: 658 path_params['accountId'] = params['account_id'] 659 660 query_params = {} 661 662 header_params = {} 663 664 form_params = [] 665 local_var_files = {} 666 667 body_params = None 668 # HTTP header `Accept` 669 header_params['Accept'] = self.api_client.\ 670 select_header_accept(['application/json']) 671 672 # Authentication setting 673 auth_settings = [] 674 675 return self.api_client.call_api(resource_path, 'DELETE', 676 path_params, 677 query_params, 678 header_params, 679 body=body_params, 680 post_params=form_params, 681 files=local_var_files, 682 response_type=None, 683 auth_settings=auth_settings, 684 callback=params.get('callback'), 685 _return_http_data_only=params.get('_return_http_data_only'), 686 _preload_content=params.get('_preload_content', True), 687 _request_timeout=params.get('_request_timeout'), 688 collection_formats=collection_formats) 689 690 def delete_account_signature(self, account_id, signature_id, **kwargs): 691 """ 692 Close the specified signature by Id. 693 694 This method makes a synchronous HTTP request by default. To make an 695 asynchronous HTTP request, please define a `callback` function 696 to be invoked when receiving the response. 697 >>> def callback_function(response): 698 >>> pprint(response) 699 >>> 700 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 701 702 :param callback function: The callback function 703 for asynchronous request. (optional) 704 :param str account_id: The external account number (int) or account ID Guid. (required) 705 :param str signature_id: The ID of the signature being accessed. (required) 706 :return: None 707 If the method is called asynchronously, 708 returns the request thread. 709 """ 710 kwargs['_return_http_data_only'] = True 711 if kwargs.get('callback'): 712 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 713 else: 714 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 715 return data 716 717 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 718 """ 719 Close the specified signature by Id. 720 721 This method makes a synchronous HTTP request by default. To make an 722 asynchronous HTTP request, please define a `callback` function 723 to be invoked when receiving the response. 724 >>> def callback_function(response): 725 >>> pprint(response) 726 >>> 727 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 728 729 :param callback function: The callback function 730 for asynchronous request. (optional) 731 :param str account_id: The external account number (int) or account ID Guid. (required) 732 :param str signature_id: The ID of the signature being accessed. (required) 733 :return: None 734 If the method is called asynchronously, 735 returns the request thread. 736 """ 737 738 all_params = ['account_id', 'signature_id'] 739 all_params.append('callback') 740 all_params.append('_return_http_data_only') 741 all_params.append('_preload_content') 742 all_params.append('_request_timeout') 743 744 params = locals() 745 for key, val in iteritems(params['kwargs']): 746 if key not in all_params: 747 raise TypeError( 748 "Got an unexpected keyword argument '%s'" 749 " to method delete_account_signature" % key 750 ) 751 params[key] = val 752 del params['kwargs'] 753 # verify the required parameter 'account_id' is set 754 if ('account_id' not in params) or (params['account_id'] is None): 755 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 756 # verify the required parameter 'signature_id' is set 757 if ('signature_id' not in params) or (params['signature_id'] is None): 758 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 759 760 761 collection_formats = {} 762 763 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 764 path_params = {} 765 if 'account_id' in params: 766 path_params['accountId'] = params['account_id'] 767 if 'signature_id' in params: 768 path_params['signatureId'] = params['signature_id'] 769 770 query_params = {} 771 772 header_params = {} 773 774 form_params = [] 775 local_var_files = {} 776 777 body_params = None 778 # HTTP header `Accept` 779 header_params['Accept'] = self.api_client.\ 780 select_header_accept(['application/json']) 781 782 # Authentication setting 783 auth_settings = [] 784 785 return self.api_client.call_api(resource_path, 'DELETE', 786 path_params, 787 query_params, 788 header_params, 789 body=body_params, 790 post_params=form_params, 791 files=local_var_files, 792 response_type=None, 793 auth_settings=auth_settings, 794 callback=params.get('callback'), 795 _return_http_data_only=params.get('_return_http_data_only'), 796 _preload_content=params.get('_preload_content', True), 797 _request_timeout=params.get('_request_timeout'), 798 collection_formats=collection_formats) 799 800 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 801 """ 802 Deletes a signature, initials, or stamps image. 803 804 This method makes a synchronous HTTP request by default. To make an 805 asynchronous HTTP request, please define a `callback` function 806 to be invoked when receiving the response. 807 >>> def callback_function(response): 808 >>> pprint(response) 809 >>> 810 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 811 812 :param callback function: The callback function 813 for asynchronous request. (optional) 814 :param str account_id: The external account number (int) or account ID Guid. (required) 815 :param str image_type: One of **signature_image** or **initials_image**. (required) 816 :param str signature_id: The ID of the signature being accessed. (required) 817 :return: AccountSignature 818 If the method is called asynchronously, 819 returns the request thread. 820 """ 821 kwargs['_return_http_data_only'] = True 822 if kwargs.get('callback'): 823 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 824 else: 825 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 826 return data 827 828 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 829 """ 830 Deletes a signature, initials, or stamps image. 831 832 This method makes a synchronous HTTP request by default. To make an 833 asynchronous HTTP request, please define a `callback` function 834 to be invoked when receiving the response. 835 >>> def callback_function(response): 836 >>> pprint(response) 837 >>> 838 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 839 840 :param callback function: The callback function 841 for asynchronous request. (optional) 842 :param str account_id: The external account number (int) or account ID Guid. (required) 843 :param str image_type: One of **signature_image** or **initials_image**. (required) 844 :param str signature_id: The ID of the signature being accessed. (required) 845 :return: AccountSignature 846 If the method is called asynchronously, 847 returns the request thread. 848 """ 849 850 all_params = ['account_id', 'image_type', 'signature_id'] 851 all_params.append('callback') 852 all_params.append('_return_http_data_only') 853 all_params.append('_preload_content') 854 all_params.append('_request_timeout') 855 856 params = locals() 857 for key, val in iteritems(params['kwargs']): 858 if key not in all_params: 859 raise TypeError( 860 "Got an unexpected keyword argument '%s'" 861 " to method delete_account_signature_image" % key 862 ) 863 params[key] = val 864 del params['kwargs'] 865 # verify the required parameter 'account_id' is set 866 if ('account_id' not in params) or (params['account_id'] is None): 867 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 868 # verify the required parameter 'image_type' is set 869 if ('image_type' not in params) or (params['image_type'] is None): 870 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 871 # verify the required parameter 'signature_id' is set 872 if ('signature_id' not in params) or (params['signature_id'] is None): 873 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 874 875 876 collection_formats = {} 877 878 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 879 path_params = {} 880 if 'account_id' in params: 881 path_params['accountId'] = params['account_id'] 882 if 'image_type' in params: 883 path_params['imageType'] = params['image_type'] 884 if 'signature_id' in params: 885 path_params['signatureId'] = params['signature_id'] 886 887 query_params = {} 888 889 header_params = {} 890 891 form_params = [] 892 local_var_files = {} 893 894 body_params = None 895 # HTTP header `Accept` 896 header_params['Accept'] = self.api_client.\ 897 select_header_accept(['application/json']) 898 899 # Authentication setting 900 auth_settings = [] 901 902 return self.api_client.call_api(resource_path, 'DELETE', 903 path_params, 904 query_params, 905 header_params, 906 body=body_params, 907 post_params=form_params, 908 files=local_var_files, 909 response_type='AccountSignature', 910 auth_settings=auth_settings, 911 callback=params.get('callback'), 912 _return_http_data_only=params.get('_return_http_data_only'), 913 _preload_content=params.get('_preload_content', True), 914 _request_timeout=params.get('_request_timeout'), 915 collection_formats=collection_formats) 916 917 def delete_brand(self, account_id, brand_id, **kwargs): 918 """ 919 Removes a brand. 920 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 921 This method makes a synchronous HTTP request by default. To make an 922 asynchronous HTTP request, please define a `callback` function 923 to be invoked when receiving the response. 924 >>> def callback_function(response): 925 >>> pprint(response) 926 >>> 927 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 928 929 :param callback function: The callback function 930 for asynchronous request. (optional) 931 :param str account_id: The external account number (int) or account ID Guid. (required) 932 :param str brand_id: The unique identifier of a brand. (required) 933 :return: None 934 If the method is called asynchronously, 935 returns the request thread. 936 """ 937 kwargs['_return_http_data_only'] = True 938 if kwargs.get('callback'): 939 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 940 else: 941 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 942 return data 943 944 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 945 """ 946 Removes a brand. 947 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 948 This method makes a synchronous HTTP request by default. To make an 949 asynchronous HTTP request, please define a `callback` function 950 to be invoked when receiving the response. 951 >>> def callback_function(response): 952 >>> pprint(response) 953 >>> 954 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 955 956 :param callback function: The callback function 957 for asynchronous request. (optional) 958 :param str account_id: The external account number (int) or account ID Guid. (required) 959 :param str brand_id: The unique identifier of a brand. (required) 960 :return: None 961 If the method is called asynchronously, 962 returns the request thread. 963 """ 964 965 all_params = ['account_id', 'brand_id'] 966 all_params.append('callback') 967 all_params.append('_return_http_data_only') 968 all_params.append('_preload_content') 969 all_params.append('_request_timeout') 970 971 params = locals() 972 for key, val in iteritems(params['kwargs']): 973 if key not in all_params: 974 raise TypeError( 975 "Got an unexpected keyword argument '%s'" 976 " to method delete_brand" % key 977 ) 978 params[key] = val 979 del params['kwargs'] 980 # verify the required parameter 'account_id' is set 981 if ('account_id' not in params) or (params['account_id'] is None): 982 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 983 # verify the required parameter 'brand_id' is set 984 if ('brand_id' not in params) or (params['brand_id'] is None): 985 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 986 987 988 collection_formats = {} 989 990 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 991 path_params = {} 992 if 'account_id' in params: 993 path_params['accountId'] = params['account_id'] 994 if 'brand_id' in params: 995 path_params['brandId'] = params['brand_id'] 996 997 query_params = {} 998 999 header_params = {} 1000 1001 form_params = [] 1002 local_var_files = {} 1003 1004 body_params = None 1005 # HTTP header `Accept` 1006 header_params['Accept'] = self.api_client.\ 1007 select_header_accept(['application/json']) 1008 1009 # Authentication setting 1010 auth_settings = [] 1011 1012 return self.api_client.call_api(resource_path, 'DELETE', 1013 path_params, 1014 query_params, 1015 header_params, 1016 body=body_params, 1017 post_params=form_params, 1018 files=local_var_files, 1019 response_type=None, 1020 auth_settings=auth_settings, 1021 callback=params.get('callback'), 1022 _return_http_data_only=params.get('_return_http_data_only'), 1023 _preload_content=params.get('_preload_content', True), 1024 _request_timeout=params.get('_request_timeout'), 1025 collection_formats=collection_formats) 1026 1027 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1028 """ 1029 Delete one branding logo. 1030 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1031 This method makes a synchronous HTTP request by default. To make an 1032 asynchronous HTTP request, please define a `callback` function 1033 to be invoked when receiving the response. 1034 >>> def callback_function(response): 1035 >>> pprint(response) 1036 >>> 1037 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1038 1039 :param callback function: The callback function 1040 for asynchronous request. (optional) 1041 :param str account_id: The external account number (int) or account ID Guid. (required) 1042 :param str brand_id: The unique identifier of a brand. (required) 1043 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1044 :return: None 1045 If the method is called asynchronously, 1046 returns the request thread. 1047 """ 1048 kwargs['_return_http_data_only'] = True 1049 if kwargs.get('callback'): 1050 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1051 else: 1052 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1053 return data 1054 1055 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1056 """ 1057 Delete one branding logo. 1058 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1059 This method makes a synchronous HTTP request by default. To make an 1060 asynchronous HTTP request, please define a `callback` function 1061 to be invoked when receiving the response. 1062 >>> def callback_function(response): 1063 >>> pprint(response) 1064 >>> 1065 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1066 1067 :param callback function: The callback function 1068 for asynchronous request. (optional) 1069 :param str account_id: The external account number (int) or account ID Guid. (required) 1070 :param str brand_id: The unique identifier of a brand. (required) 1071 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1072 :return: None 1073 If the method is called asynchronously, 1074 returns the request thread. 1075 """ 1076 1077 all_params = ['account_id', 'brand_id', 'logo_type'] 1078 all_params.append('callback') 1079 all_params.append('_return_http_data_only') 1080 all_params.append('_preload_content') 1081 all_params.append('_request_timeout') 1082 1083 params = locals() 1084 for key, val in iteritems(params['kwargs']): 1085 if key not in all_params: 1086 raise TypeError( 1087 "Got an unexpected keyword argument '%s'" 1088 " to method delete_brand_logo_by_type" % key 1089 ) 1090 params[key] = val 1091 del params['kwargs'] 1092 # verify the required parameter 'account_id' is set 1093 if ('account_id' not in params) or (params['account_id'] is None): 1094 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1095 # verify the required parameter 'brand_id' is set 1096 if ('brand_id' not in params) or (params['brand_id'] is None): 1097 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1098 # verify the required parameter 'logo_type' is set 1099 if ('logo_type' not in params) or (params['logo_type'] is None): 1100 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1101 1102 1103 collection_formats = {} 1104 1105 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1106 path_params = {} 1107 if 'account_id' in params: 1108 path_params['accountId'] = params['account_id'] 1109 if 'brand_id' in params: 1110 path_params['brandId'] = params['brand_id'] 1111 if 'logo_type' in params: 1112 path_params['logoType'] = params['logo_type'] 1113 1114 query_params = {} 1115 1116 header_params = {} 1117 1118 form_params = [] 1119 local_var_files = {} 1120 1121 body_params = None 1122 # HTTP header `Accept` 1123 header_params['Accept'] = self.api_client.\ 1124 select_header_accept(['application/json']) 1125 1126 # Authentication setting 1127 auth_settings = [] 1128 1129 return self.api_client.call_api(resource_path, 'DELETE', 1130 path_params, 1131 query_params, 1132 header_params, 1133 body=body_params, 1134 post_params=form_params, 1135 files=local_var_files, 1136 response_type=None, 1137 auth_settings=auth_settings, 1138 callback=params.get('callback'), 1139 _return_http_data_only=params.get('_return_http_data_only'), 1140 _preload_content=params.get('_preload_content', True), 1141 _request_timeout=params.get('_request_timeout'), 1142 collection_formats=collection_formats) 1143 1144 def delete_brands(self, account_id, **kwargs): 1145 """ 1146 Deletes one or more brand profiles. 1147 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1148 This method makes a synchronous HTTP request by default. To make an 1149 asynchronous HTTP request, please define a `callback` function 1150 to be invoked when receiving the response. 1151 >>> def callback_function(response): 1152 >>> pprint(response) 1153 >>> 1154 >>> thread = api.delete_brands(account_id, callback=callback_function) 1155 1156 :param callback function: The callback function 1157 for asynchronous request. (optional) 1158 :param str account_id: The external account number (int) or account ID Guid. (required) 1159 :param BrandsRequest brands_request: 1160 :return: BrandsResponse 1161 If the method is called asynchronously, 1162 returns the request thread. 1163 """ 1164 kwargs['_return_http_data_only'] = True 1165 if kwargs.get('callback'): 1166 return self.delete_brands_with_http_info(account_id, **kwargs) 1167 else: 1168 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1169 return data 1170 1171 def delete_brands_with_http_info(self, account_id, **kwargs): 1172 """ 1173 Deletes one or more brand profiles. 1174 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1175 This method makes a synchronous HTTP request by default. To make an 1176 asynchronous HTTP request, please define a `callback` function 1177 to be invoked when receiving the response. 1178 >>> def callback_function(response): 1179 >>> pprint(response) 1180 >>> 1181 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1182 1183 :param callback function: The callback function 1184 for asynchronous request. (optional) 1185 :param str account_id: The external account number (int) or account ID Guid. (required) 1186 :param BrandsRequest brands_request: 1187 :return: BrandsResponse 1188 If the method is called asynchronously, 1189 returns the request thread. 1190 """ 1191 1192 all_params = ['account_id', 'brands_request'] 1193 all_params.append('callback') 1194 all_params.append('_return_http_data_only') 1195 all_params.append('_preload_content') 1196 all_params.append('_request_timeout') 1197 1198 params = locals() 1199 for key, val in iteritems(params['kwargs']): 1200 if key not in all_params: 1201 raise TypeError( 1202 "Got an unexpected keyword argument '%s'" 1203 " to method delete_brands" % key 1204 ) 1205 params[key] = val 1206 del params['kwargs'] 1207 # verify the required parameter 'account_id' is set 1208 if ('account_id' not in params) or (params['account_id'] is None): 1209 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1210 1211 1212 collection_formats = {} 1213 1214 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1215 path_params = {} 1216 if 'account_id' in params: 1217 path_params['accountId'] = params['account_id'] 1218 1219 query_params = {} 1220 1221 header_params = {} 1222 1223 form_params = [] 1224 local_var_files = {} 1225 1226 body_params = None 1227 if 'brands_request' in params: 1228 body_params = params['brands_request'] 1229 # HTTP header `Accept` 1230 header_params['Accept'] = self.api_client.\ 1231 select_header_accept(['application/json']) 1232 1233 # Authentication setting 1234 auth_settings = [] 1235 1236 return self.api_client.call_api(resource_path, 'DELETE', 1237 path_params, 1238 query_params, 1239 header_params, 1240 body=body_params, 1241 post_params=form_params, 1242 files=local_var_files, 1243 response_type='BrandsResponse', 1244 auth_settings=auth_settings, 1245 callback=params.get('callback'), 1246 _return_http_data_only=params.get('_return_http_data_only'), 1247 _preload_content=params.get('_preload_content', True), 1248 _request_timeout=params.get('_request_timeout'), 1249 collection_formats=collection_formats) 1250 1251 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1252 """ 1253 Deletes the signature for one or more captive recipient records. 1254 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1255 This method makes a synchronous HTTP request by default. To make an 1256 asynchronous HTTP request, please define a `callback` function 1257 to be invoked when receiving the response. 1258 >>> def callback_function(response): 1259 >>> pprint(response) 1260 >>> 1261 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1262 1263 :param callback function: The callback function 1264 for asynchronous request. (optional) 1265 :param str account_id: The external account number (int) or account ID Guid. (required) 1266 :param str recipient_part: (required) 1267 :param CaptiveRecipientInformation captive_recipient_information: 1268 :return: CaptiveRecipientInformation 1269 If the method is called asynchronously, 1270 returns the request thread. 1271 """ 1272 kwargs['_return_http_data_only'] = True 1273 if kwargs.get('callback'): 1274 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1275 else: 1276 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1277 return data 1278 1279 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1280 """ 1281 Deletes the signature for one or more captive recipient records. 1282 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1283 This method makes a synchronous HTTP request by default. To make an 1284 asynchronous HTTP request, please define a `callback` function 1285 to be invoked when receiving the response. 1286 >>> def callback_function(response): 1287 >>> pprint(response) 1288 >>> 1289 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1290 1291 :param callback function: The callback function 1292 for asynchronous request. (optional) 1293 :param str account_id: The external account number (int) or account ID Guid. (required) 1294 :param str recipient_part: (required) 1295 :param CaptiveRecipientInformation captive_recipient_information: 1296 :return: CaptiveRecipientInformation 1297 If the method is called asynchronously, 1298 returns the request thread. 1299 """ 1300 1301 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1302 all_params.append('callback') 1303 all_params.append('_return_http_data_only') 1304 all_params.append('_preload_content') 1305 all_params.append('_request_timeout') 1306 1307 params = locals() 1308 for key, val in iteritems(params['kwargs']): 1309 if key not in all_params: 1310 raise TypeError( 1311 "Got an unexpected keyword argument '%s'" 1312 " to method delete_captive_recipient" % key 1313 ) 1314 params[key] = val 1315 del params['kwargs'] 1316 # verify the required parameter 'account_id' is set 1317 if ('account_id' not in params) or (params['account_id'] is None): 1318 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1319 # verify the required parameter 'recipient_part' is set 1320 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1321 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1322 1323 1324 collection_formats = {} 1325 1326 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1327 path_params = {} 1328 if 'account_id' in params: 1329 path_params['accountId'] = params['account_id'] 1330 if 'recipient_part' in params: 1331 path_params['recipientPart'] = params['recipient_part'] 1332 1333 query_params = {} 1334 1335 header_params = {} 1336 1337 form_params = [] 1338 local_var_files = {} 1339 1340 body_params = None 1341 if 'captive_recipient_information' in params: 1342 body_params = params['captive_recipient_information'] 1343 # HTTP header `Accept` 1344 header_params['Accept'] = self.api_client.\ 1345 select_header_accept(['application/json']) 1346 1347 # Authentication setting 1348 auth_settings = [] 1349 1350 return self.api_client.call_api(resource_path, 'DELETE', 1351 path_params, 1352 query_params, 1353 header_params, 1354 body=body_params, 1355 post_params=form_params, 1356 files=local_var_files, 1357 response_type='CaptiveRecipientInformation', 1358 auth_settings=auth_settings, 1359 callback=params.get('callback'), 1360 _return_http_data_only=params.get('_return_http_data_only'), 1361 _preload_content=params.get('_preload_content', True), 1362 _request_timeout=params.get('_request_timeout'), 1363 collection_formats=collection_formats) 1364 1365 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1366 """ 1367 Delete an existing account custom field. 1368 This method deletes an existing account custom field. 1369 This method makes a synchronous HTTP request by default. To make an 1370 asynchronous HTTP request, please define a `callback` function 1371 to be invoked when receiving the response. 1372 >>> def callback_function(response): 1373 >>> pprint(response) 1374 >>> 1375 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1376 1377 :param callback function: The callback function 1378 for asynchronous request. (optional) 1379 :param str account_id: The external account number (int) or account ID Guid. (required) 1380 :param str custom_field_id: (required) 1381 :param str apply_to_templates: 1382 :return: None 1383 If the method is called asynchronously, 1384 returns the request thread. 1385 """ 1386 kwargs['_return_http_data_only'] = True 1387 if kwargs.get('callback'): 1388 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1389 else: 1390 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1391 return data 1392 1393 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1394 """ 1395 Delete an existing account custom field. 1396 This method deletes an existing account custom field. 1397 This method makes a synchronous HTTP request by default. To make an 1398 asynchronous HTTP request, please define a `callback` function 1399 to be invoked when receiving the response. 1400 >>> def callback_function(response): 1401 >>> pprint(response) 1402 >>> 1403 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1404 1405 :param callback function: The callback function 1406 for asynchronous request. (optional) 1407 :param str account_id: The external account number (int) or account ID Guid. (required) 1408 :param str custom_field_id: (required) 1409 :param str apply_to_templates: 1410 :return: None 1411 If the method is called asynchronously, 1412 returns the request thread. 1413 """ 1414 1415 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1416 all_params.append('callback') 1417 all_params.append('_return_http_data_only') 1418 all_params.append('_preload_content') 1419 all_params.append('_request_timeout') 1420 1421 params = locals() 1422 for key, val in iteritems(params['kwargs']): 1423 if key not in all_params: 1424 raise TypeError( 1425 "Got an unexpected keyword argument '%s'" 1426 " to method delete_custom_field" % key 1427 ) 1428 params[key] = val 1429 del params['kwargs'] 1430 # verify the required parameter 'account_id' is set 1431 if ('account_id' not in params) or (params['account_id'] is None): 1432 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1433 # verify the required parameter 'custom_field_id' is set 1434 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1435 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1436 1437 1438 collection_formats = {} 1439 1440 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1441 path_params = {} 1442 if 'account_id' in params: 1443 path_params['accountId'] = params['account_id'] 1444 if 'custom_field_id' in params: 1445 path_params['customFieldId'] = params['custom_field_id'] 1446 1447 query_params = {} 1448 if 'apply_to_templates' in params: 1449 query_params['apply_to_templates'] = params['apply_to_templates'] 1450 1451 header_params = {} 1452 1453 form_params = [] 1454 local_var_files = {} 1455 1456 body_params = None 1457 # HTTP header `Accept` 1458 header_params['Accept'] = self.api_client.\ 1459 select_header_accept(['application/json']) 1460 1461 # Authentication setting 1462 auth_settings = [] 1463 1464 return self.api_client.call_api(resource_path, 'DELETE', 1465 path_params, 1466 query_params, 1467 header_params, 1468 body=body_params, 1469 post_params=form_params, 1470 files=local_var_files, 1471 response_type=None, 1472 auth_settings=auth_settings, 1473 callback=params.get('callback'), 1474 _return_http_data_only=params.get('_return_http_data_only'), 1475 _preload_content=params.get('_preload_content', True), 1476 _request_timeout=params.get('_request_timeout'), 1477 collection_formats=collection_formats) 1478 1479 def delete_e_note_configuration(self, account_id, **kwargs): 1480 """ 1481 Deletes configuration information for the eNote eOriginal integration. 1482 1483 This method makes a synchronous HTTP request by default. To make an 1484 asynchronous HTTP request, please define a `callback` function 1485 to be invoked when receiving the response. 1486 >>> def callback_function(response): 1487 >>> pprint(response) 1488 >>> 1489 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1490 1491 :param callback function: The callback function 1492 for asynchronous request. (optional) 1493 :param str account_id: The external account number (int) or account ID Guid. (required) 1494 :return: None 1495 If the method is called asynchronously, 1496 returns the request thread. 1497 """ 1498 kwargs['_return_http_data_only'] = True 1499 if kwargs.get('callback'): 1500 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1501 else: 1502 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1503 return data 1504 1505 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1506 """ 1507 Deletes configuration information for the eNote eOriginal integration. 1508 1509 This method makes a synchronous HTTP request by default. To make an 1510 asynchronous HTTP request, please define a `callback` function 1511 to be invoked when receiving the response. 1512 >>> def callback_function(response): 1513 >>> pprint(response) 1514 >>> 1515 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1516 1517 :param callback function: The callback function 1518 for asynchronous request. (optional) 1519 :param str account_id: The external account number (int) or account ID Guid. (required) 1520 :return: None 1521 If the method is called asynchronously, 1522 returns the request thread. 1523 """ 1524 1525 all_params = ['account_id'] 1526 all_params.append('callback') 1527 all_params.append('_return_http_data_only') 1528 all_params.append('_preload_content') 1529 all_params.append('_request_timeout') 1530 1531 params = locals() 1532 for key, val in iteritems(params['kwargs']): 1533 if key not in all_params: 1534 raise TypeError( 1535 "Got an unexpected keyword argument '%s'" 1536 " to method delete_e_note_configuration" % key 1537 ) 1538 params[key] = val 1539 del params['kwargs'] 1540 # verify the required parameter 'account_id' is set 1541 if ('account_id' not in params) or (params['account_id'] is None): 1542 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1543 1544 1545 collection_formats = {} 1546 1547 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1548 path_params = {} 1549 if 'account_id' in params: 1550 path_params['accountId'] = params['account_id'] 1551 1552 query_params = {} 1553 1554 header_params = {} 1555 1556 form_params = [] 1557 local_var_files = {} 1558 1559 body_params = None 1560 # HTTP header `Accept` 1561 header_params['Accept'] = self.api_client.\ 1562 select_header_accept(['application/json']) 1563 1564 # Authentication setting 1565 auth_settings = [] 1566 1567 return self.api_client.call_api(resource_path, 'DELETE', 1568 path_params, 1569 query_params, 1570 header_params, 1571 body=body_params, 1572 post_params=form_params, 1573 files=local_var_files, 1574 response_type=None, 1575 auth_settings=auth_settings, 1576 callback=params.get('callback'), 1577 _return_http_data_only=params.get('_return_http_data_only'), 1578 _preload_content=params.get('_preload_content', True), 1579 _request_timeout=params.get('_request_timeout'), 1580 collection_formats=collection_formats) 1581 1582 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1583 """ 1584 Deletes a permissions profile within the specified account. 1585 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1586 This method makes a synchronous HTTP request by default. To make an 1587 asynchronous HTTP request, please define a `callback` function 1588 to be invoked when receiving the response. 1589 >>> def callback_function(response): 1590 >>> pprint(response) 1591 >>> 1592 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1593 1594 :param callback function: The callback function 1595 for asynchronous request. (optional) 1596 :param str account_id: The external account number (int) or account ID Guid. (required) 1597 :param str permission_profile_id: (required) 1598 :param str move_users_to: 1599 :return: None 1600 If the method is called asynchronously, 1601 returns the request thread. 1602 """ 1603 kwargs['_return_http_data_only'] = True 1604 if kwargs.get('callback'): 1605 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1606 else: 1607 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1608 return data 1609 1610 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1611 """ 1612 Deletes a permissions profile within the specified account. 1613 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1614 This method makes a synchronous HTTP request by default. To make an 1615 asynchronous HTTP request, please define a `callback` function 1616 to be invoked when receiving the response. 1617 >>> def callback_function(response): 1618 >>> pprint(response) 1619 >>> 1620 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1621 1622 :param callback function: The callback function 1623 for asynchronous request. (optional) 1624 :param str account_id: The external account number (int) or account ID Guid. (required) 1625 :param str permission_profile_id: (required) 1626 :param str move_users_to: 1627 :return: None 1628 If the method is called asynchronously, 1629 returns the request thread. 1630 """ 1631 1632 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1633 all_params.append('callback') 1634 all_params.append('_return_http_data_only') 1635 all_params.append('_preload_content') 1636 all_params.append('_request_timeout') 1637 1638 params = locals() 1639 for key, val in iteritems(params['kwargs']): 1640 if key not in all_params: 1641 raise TypeError( 1642 "Got an unexpected keyword argument '%s'" 1643 " to method delete_permission_profile" % key 1644 ) 1645 params[key] = val 1646 del params['kwargs'] 1647 # verify the required parameter 'account_id' is set 1648 if ('account_id' not in params) or (params['account_id'] is None): 1649 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1650 # verify the required parameter 'permission_profile_id' is set 1651 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1652 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1653 1654 1655 collection_formats = {} 1656 1657 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1658 path_params = {} 1659 if 'account_id' in params: 1660 path_params['accountId'] = params['account_id'] 1661 if 'permission_profile_id' in params: 1662 path_params['permissionProfileId'] = params['permission_profile_id'] 1663 1664 query_params = {} 1665 if 'move_users_to' in params: 1666 query_params['move_users_to'] = params['move_users_to'] 1667 1668 header_params = {} 1669 1670 form_params = [] 1671 local_var_files = {} 1672 1673 body_params = None 1674 # HTTP header `Accept` 1675 header_params['Accept'] = self.api_client.\ 1676 select_header_accept(['application/json']) 1677 1678 # Authentication setting 1679 auth_settings = [] 1680 1681 return self.api_client.call_api(resource_path, 'DELETE', 1682 path_params, 1683 query_params, 1684 header_params, 1685 body=body_params, 1686 post_params=form_params, 1687 files=local_var_files, 1688 response_type=None, 1689 auth_settings=auth_settings, 1690 callback=params.get('callback'), 1691 _return_http_data_only=params.get('_return_http_data_only'), 1692 _preload_content=params.get('_preload_content', True), 1693 _request_timeout=params.get('_request_timeout'), 1694 collection_formats=collection_formats) 1695 1696 def get_account_identity_verification(self, account_id, **kwargs): 1697 """ 1698 Get the list of identity verification options for an account 1699 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 1700 This method makes a synchronous HTTP request by default. To make an 1701 asynchronous HTTP request, please define a `callback` function 1702 to be invoked when receiving the response. 1703 >>> def callback_function(response): 1704 >>> pprint(response) 1705 >>> 1706 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 1707 1708 :param callback function: The callback function 1709 for asynchronous request. (optional) 1710 :param str account_id: The external account number (int) or account ID Guid. (required) 1711 :return: AccountIdentityVerificationResponse 1712 If the method is called asynchronously, 1713 returns the request thread. 1714 """ 1715 kwargs['_return_http_data_only'] = True 1716 if kwargs.get('callback'): 1717 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 1718 else: 1719 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 1720 return data 1721 1722 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 1723 """ 1724 Get the list of identity verification options for an account 1725 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 1726 This method makes a synchronous HTTP request by default. To make an 1727 asynchronous HTTP request, please define a `callback` function 1728 to be invoked when receiving the response. 1729 >>> def callback_function(response): 1730 >>> pprint(response) 1731 >>> 1732 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 1733 1734 :param callback function: The callback function 1735 for asynchronous request. (optional) 1736 :param str account_id: The external account number (int) or account ID Guid. (required) 1737 :return: AccountIdentityVerificationResponse 1738 If the method is called asynchronously, 1739 returns the request thread. 1740 """ 1741 1742 all_params = ['account_id'] 1743 all_params.append('callback') 1744 all_params.append('_return_http_data_only') 1745 all_params.append('_preload_content') 1746 all_params.append('_request_timeout') 1747 1748 params = locals() 1749 for key, val in iteritems(params['kwargs']): 1750 if key not in all_params: 1751 raise TypeError( 1752 "Got an unexpected keyword argument '%s'" 1753 " to method get_account_identity_verification" % key 1754 ) 1755 params[key] = val 1756 del params['kwargs'] 1757 # verify the required parameter 'account_id' is set 1758 if ('account_id' not in params) or (params['account_id'] is None): 1759 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 1760 1761 1762 collection_formats = {} 1763 1764 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 1765 path_params = {} 1766 if 'account_id' in params: 1767 path_params['accountId'] = params['account_id'] 1768 1769 query_params = {} 1770 1771 header_params = {} 1772 1773 form_params = [] 1774 local_var_files = {} 1775 1776 body_params = None 1777 # HTTP header `Accept` 1778 header_params['Accept'] = self.api_client.\ 1779 select_header_accept(['application/json']) 1780 1781 # Authentication setting 1782 auth_settings = [] 1783 1784 return self.api_client.call_api(resource_path, 'GET', 1785 path_params, 1786 query_params, 1787 header_params, 1788 body=body_params, 1789 post_params=form_params, 1790 files=local_var_files, 1791 response_type='AccountIdentityVerificationResponse', 1792 auth_settings=auth_settings, 1793 callback=params.get('callback'), 1794 _return_http_data_only=params.get('_return_http_data_only'), 1795 _preload_content=params.get('_preload_content', True), 1796 _request_timeout=params.get('_request_timeout'), 1797 collection_formats=collection_formats) 1798 1799 def get_account_information(self, account_id, **kwargs): 1800 """ 1801 Retrieves the account information for the specified account. 1802 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 1803 This method makes a synchronous HTTP request by default. To make an 1804 asynchronous HTTP request, please define a `callback` function 1805 to be invoked when receiving the response. 1806 >>> def callback_function(response): 1807 >>> pprint(response) 1808 >>> 1809 >>> thread = api.get_account_information(account_id, callback=callback_function) 1810 1811 :param callback function: The callback function 1812 for asynchronous request. (optional) 1813 :param str account_id: The external account number (int) or account ID Guid. (required) 1814 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 1815 :return: AccountInformation 1816 If the method is called asynchronously, 1817 returns the request thread. 1818 """ 1819 kwargs['_return_http_data_only'] = True 1820 if kwargs.get('callback'): 1821 return self.get_account_information_with_http_info(account_id, **kwargs) 1822 else: 1823 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 1824 return data 1825 1826 def get_account_information_with_http_info(self, account_id, **kwargs): 1827 """ 1828 Retrieves the account information for the specified account. 1829 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 1830 This method makes a synchronous HTTP request by default. To make an 1831 asynchronous HTTP request, please define a `callback` function 1832 to be invoked when receiving the response. 1833 >>> def callback_function(response): 1834 >>> pprint(response) 1835 >>> 1836 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 1837 1838 :param callback function: The callback function 1839 for asynchronous request. (optional) 1840 :param str account_id: The external account number (int) or account ID Guid. (required) 1841 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 1842 :return: AccountInformation 1843 If the method is called asynchronously, 1844 returns the request thread. 1845 """ 1846 1847 all_params = ['account_id', 'include_account_settings'] 1848 all_params.append('callback') 1849 all_params.append('_return_http_data_only') 1850 all_params.append('_preload_content') 1851 all_params.append('_request_timeout') 1852 1853 params = locals() 1854 for key, val in iteritems(params['kwargs']): 1855 if key not in all_params: 1856 raise TypeError( 1857 "Got an unexpected keyword argument '%s'" 1858 " to method get_account_information" % key 1859 ) 1860 params[key] = val 1861 del params['kwargs'] 1862 # verify the required parameter 'account_id' is set 1863 if ('account_id' not in params) or (params['account_id'] is None): 1864 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 1865 1866 1867 collection_formats = {} 1868 1869 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 1870 path_params = {} 1871 if 'account_id' in params: 1872 path_params['accountId'] = params['account_id'] 1873 1874 query_params = {} 1875 if 'include_account_settings' in params: 1876 query_params['include_account_settings'] = params['include_account_settings'] 1877 1878 header_params = {} 1879 1880 form_params = [] 1881 local_var_files = {} 1882 1883 body_params = None 1884 # HTTP header `Accept` 1885 header_params['Accept'] = self.api_client.\ 1886 select_header_accept(['application/json']) 1887 1888 # Authentication setting 1889 auth_settings = [] 1890 1891 return self.api_client.call_api(resource_path, 'GET', 1892 path_params, 1893 query_params, 1894 header_params, 1895 body=body_params, 1896 post_params=form_params, 1897 files=local_var_files, 1898 response_type='AccountInformation', 1899 auth_settings=auth_settings, 1900 callback=params.get('callback'), 1901 _return_http_data_only=params.get('_return_http_data_only'), 1902 _preload_content=params.get('_preload_content', True), 1903 _request_timeout=params.get('_request_timeout'), 1904 collection_formats=collection_formats) 1905 1906 def get_account_signature(self, account_id, signature_id, **kwargs): 1907 """ 1908 Returns information about a single signature by specifed signatureId. 1909 1910 This method makes a synchronous HTTP request by default. To make an 1911 asynchronous HTTP request, please define a `callback` function 1912 to be invoked when receiving the response. 1913 >>> def callback_function(response): 1914 >>> pprint(response) 1915 >>> 1916 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 1917 1918 :param callback function: The callback function 1919 for asynchronous request. (optional) 1920 :param str account_id: The external account number (int) or account ID Guid. (required) 1921 :param str signature_id: The ID of the signature being accessed. (required) 1922 :return: AccountSignature 1923 If the method is called asynchronously, 1924 returns the request thread. 1925 """ 1926 kwargs['_return_http_data_only'] = True 1927 if kwargs.get('callback'): 1928 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 1929 else: 1930 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 1931 return data 1932 1933 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 1934 """ 1935 Returns information about a single signature by specifed signatureId. 1936 1937 This method makes a synchronous HTTP request by default. To make an 1938 asynchronous HTTP request, please define a `callback` function 1939 to be invoked when receiving the response. 1940 >>> def callback_function(response): 1941 >>> pprint(response) 1942 >>> 1943 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 1944 1945 :param callback function: The callback function 1946 for asynchronous request. (optional) 1947 :param str account_id: The external account number (int) or account ID Guid. (required) 1948 :param str signature_id: The ID of the signature being accessed. (required) 1949 :return: AccountSignature 1950 If the method is called asynchronously, 1951 returns the request thread. 1952 """ 1953 1954 all_params = ['account_id', 'signature_id'] 1955 all_params.append('callback') 1956 all_params.append('_return_http_data_only') 1957 all_params.append('_preload_content') 1958 all_params.append('_request_timeout') 1959 1960 params = locals() 1961 for key, val in iteritems(params['kwargs']): 1962 if key not in all_params: 1963 raise TypeError( 1964 "Got an unexpected keyword argument '%s'" 1965 " to method get_account_signature" % key 1966 ) 1967 params[key] = val 1968 del params['kwargs'] 1969 # verify the required parameter 'account_id' is set 1970 if ('account_id' not in params) or (params['account_id'] is None): 1971 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 1972 # verify the required parameter 'signature_id' is set 1973 if ('signature_id' not in params) or (params['signature_id'] is None): 1974 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 1975 1976 1977 collection_formats = {} 1978 1979 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 1980 path_params = {} 1981 if 'account_id' in params: 1982 path_params['accountId'] = params['account_id'] 1983 if 'signature_id' in params: 1984 path_params['signatureId'] = params['signature_id'] 1985 1986 query_params = {} 1987 1988 header_params = {} 1989 1990 form_params = [] 1991 local_var_files = {} 1992 1993 body_params = None 1994 # HTTP header `Accept` 1995 header_params['Accept'] = self.api_client.\ 1996 select_header_accept(['application/json']) 1997 1998 # Authentication setting 1999 auth_settings = [] 2000 2001 return self.api_client.call_api(resource_path, 'GET', 2002 path_params, 2003 query_params, 2004 header_params, 2005 body=body_params, 2006 post_params=form_params, 2007 files=local_var_files, 2008 response_type='AccountSignature', 2009 auth_settings=auth_settings, 2010 callback=params.get('callback'), 2011 _return_http_data_only=params.get('_return_http_data_only'), 2012 _preload_content=params.get('_preload_content', True), 2013 _request_timeout=params.get('_request_timeout'), 2014 collection_formats=collection_formats) 2015 2016 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2017 """ 2018 Returns a signature, initials, or stamps image. 2019 2020 This method makes a synchronous HTTP request by default. To make an 2021 asynchronous HTTP request, please define a `callback` function 2022 to be invoked when receiving the response. 2023 >>> def callback_function(response): 2024 >>> pprint(response) 2025 >>> 2026 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2027 2028 :param callback function: The callback function 2029 for asynchronous request. (optional) 2030 :param str account_id: The external account number (int) or account ID Guid. (required) 2031 :param str image_type: One of **signature_image** or **initials_image**. (required) 2032 :param str signature_id: The ID of the signature being accessed. (required) 2033 :param str include_chrome: 2034 :return: file 2035 If the method is called asynchronously, 2036 returns the request thread. 2037 """ 2038 kwargs['_return_http_data_only'] = True 2039 if kwargs.get('callback'): 2040 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2041 else: 2042 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2043 return data 2044 2045 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2046 """ 2047 Returns a signature, initials, or stamps image. 2048 2049 This method makes a synchronous HTTP request by default. To make an 2050 asynchronous HTTP request, please define a `callback` function 2051 to be invoked when receiving the response. 2052 >>> def callback_function(response): 2053 >>> pprint(response) 2054 >>> 2055 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2056 2057 :param callback function: The callback function 2058 for asynchronous request. (optional) 2059 :param str account_id: The external account number (int) or account ID Guid. (required) 2060 :param str image_type: One of **signature_image** or **initials_image**. (required) 2061 :param str signature_id: The ID of the signature being accessed. (required) 2062 :param str include_chrome: 2063 :return: file 2064 If the method is called asynchronously, 2065 returns the request thread. 2066 """ 2067 2068 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2069 all_params.append('callback') 2070 all_params.append('_return_http_data_only') 2071 all_params.append('_preload_content') 2072 all_params.append('_request_timeout') 2073 2074 params = locals() 2075 for key, val in iteritems(params['kwargs']): 2076 if key not in all_params: 2077 raise TypeError( 2078 "Got an unexpected keyword argument '%s'" 2079 " to method get_account_signature_image" % key 2080 ) 2081 params[key] = val 2082 del params['kwargs'] 2083 # verify the required parameter 'account_id' is set 2084 if ('account_id' not in params) or (params['account_id'] is None): 2085 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2086 # verify the required parameter 'image_type' is set 2087 if ('image_type' not in params) or (params['image_type'] is None): 2088 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2089 # verify the required parameter 'signature_id' is set 2090 if ('signature_id' not in params) or (params['signature_id'] is None): 2091 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2092 2093 2094 collection_formats = {} 2095 2096 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2097 path_params = {} 2098 if 'account_id' in params: 2099 path_params['accountId'] = params['account_id'] 2100 if 'image_type' in params: 2101 path_params['imageType'] = params['image_type'] 2102 if 'signature_id' in params: 2103 path_params['signatureId'] = params['signature_id'] 2104 2105 query_params = {} 2106 if 'include_chrome' in params: 2107 query_params['include_chrome'] = params['include_chrome'] 2108 2109 header_params = {} 2110 2111 form_params = [] 2112 local_var_files = {} 2113 2114 body_params = None 2115 # HTTP header `Accept` 2116 header_params['Accept'] = self.api_client.\ 2117 select_header_accept(['image/gif']) 2118 2119 # Authentication setting 2120 auth_settings = [] 2121 2122 return self.api_client.call_api(resource_path, 'GET', 2123 path_params, 2124 query_params, 2125 header_params, 2126 body=body_params, 2127 post_params=form_params, 2128 files=local_var_files, 2129 response_type='file', 2130 auth_settings=auth_settings, 2131 callback=params.get('callback'), 2132 _return_http_data_only=params.get('_return_http_data_only'), 2133 _preload_content=params.get('_preload_content', True), 2134 _request_timeout=params.get('_request_timeout'), 2135 collection_formats=collection_formats) 2136 2137 def get_account_signatures(self, account_id, **kwargs): 2138 """ 2139 Returns the managed signature definitions for the account 2140 2141 This method makes a synchronous HTTP request by default. To make an 2142 asynchronous HTTP request, please define a `callback` function 2143 to be invoked when receiving the response. 2144 >>> def callback_function(response): 2145 >>> pprint(response) 2146 >>> 2147 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2148 2149 :param callback function: The callback function 2150 for asynchronous request. (optional) 2151 :param str account_id: The external account number (int) or account ID Guid. (required) 2152 :param str stamp_format: 2153 :param str stamp_name: 2154 :param str stamp_type: 2155 :return: AccountSignaturesInformation 2156 If the method is called asynchronously, 2157 returns the request thread. 2158 """ 2159 kwargs['_return_http_data_only'] = True 2160 if kwargs.get('callback'): 2161 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2162 else: 2163 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2164 return data 2165 2166 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2167 """ 2168 Returns the managed signature definitions for the account 2169 2170 This method makes a synchronous HTTP request by default. To make an 2171 asynchronous HTTP request, please define a `callback` function 2172 to be invoked when receiving the response. 2173 >>> def callback_function(response): 2174 >>> pprint(response) 2175 >>> 2176 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2177 2178 :param callback function: The callback function 2179 for asynchronous request. (optional) 2180 :param str account_id: The external account number (int) or account ID Guid. (required) 2181 :param str stamp_format: 2182 :param str stamp_name: 2183 :param str stamp_type: 2184 :return: AccountSignaturesInformation 2185 If the method is called asynchronously, 2186 returns the request thread. 2187 """ 2188 2189 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2190 all_params.append('callback') 2191 all_params.append('_return_http_data_only') 2192 all_params.append('_preload_content') 2193 all_params.append('_request_timeout') 2194 2195 params = locals() 2196 for key, val in iteritems(params['kwargs']): 2197 if key not in all_params: 2198 raise TypeError( 2199 "Got an unexpected keyword argument '%s'" 2200 " to method get_account_signatures" % key 2201 ) 2202 params[key] = val 2203 del params['kwargs'] 2204 # verify the required parameter 'account_id' is set 2205 if ('account_id' not in params) or (params['account_id'] is None): 2206 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2207 2208 2209 collection_formats = {} 2210 2211 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2212 path_params = {} 2213 if 'account_id' in params: 2214 path_params['accountId'] = params['account_id'] 2215 2216 query_params = {} 2217 if 'stamp_format' in params: 2218 query_params['stamp_format'] = params['stamp_format'] 2219 if 'stamp_name' in params: 2220 query_params['stamp_name'] = params['stamp_name'] 2221 if 'stamp_type' in params: 2222 query_params['stamp_type'] = params['stamp_type'] 2223 2224 header_params = {} 2225 2226 form_params = [] 2227 local_var_files = {} 2228 2229 body_params = None 2230 # HTTP header `Accept` 2231 header_params['Accept'] = self.api_client.\ 2232 select_header_accept(['application/json']) 2233 2234 # Authentication setting 2235 auth_settings = [] 2236 2237 return self.api_client.call_api(resource_path, 'GET', 2238 path_params, 2239 query_params, 2240 header_params, 2241 body=body_params, 2242 post_params=form_params, 2243 files=local_var_files, 2244 response_type='AccountSignaturesInformation', 2245 auth_settings=auth_settings, 2246 callback=params.get('callback'), 2247 _return_http_data_only=params.get('_return_http_data_only'), 2248 _preload_content=params.get('_preload_content', True), 2249 _request_timeout=params.get('_request_timeout'), 2250 collection_formats=collection_formats) 2251 2252 def get_account_tab_settings(self, account_id, **kwargs): 2253 """ 2254 Returns tab settings list for specified account 2255 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2256 This method makes a synchronous HTTP request by default. To make an 2257 asynchronous HTTP request, please define a `callback` function 2258 to be invoked when receiving the response. 2259 >>> def callback_function(response): 2260 >>> pprint(response) 2261 >>> 2262 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2263 2264 :param callback function: The callback function 2265 for asynchronous request. (optional) 2266 :param str account_id: The external account number (int) or account ID Guid. (required) 2267 :return: TabAccountSettings 2268 If the method is called asynchronously, 2269 returns the request thread. 2270 """ 2271 kwargs['_return_http_data_only'] = True 2272 if kwargs.get('callback'): 2273 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2274 else: 2275 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2276 return data 2277 2278 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2279 """ 2280 Returns tab settings list for specified account 2281 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2282 This method makes a synchronous HTTP request by default. To make an 2283 asynchronous HTTP request, please define a `callback` function 2284 to be invoked when receiving the response. 2285 >>> def callback_function(response): 2286 >>> pprint(response) 2287 >>> 2288 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2289 2290 :param callback function: The callback function 2291 for asynchronous request. (optional) 2292 :param str account_id: The external account number (int) or account ID Guid. (required) 2293 :return: TabAccountSettings 2294 If the method is called asynchronously, 2295 returns the request thread. 2296 """ 2297 2298 all_params = ['account_id'] 2299 all_params.append('callback') 2300 all_params.append('_return_http_data_only') 2301 all_params.append('_preload_content') 2302 all_params.append('_request_timeout') 2303 2304 params = locals() 2305 for key, val in iteritems(params['kwargs']): 2306 if key not in all_params: 2307 raise TypeError( 2308 "Got an unexpected keyword argument '%s'" 2309 " to method get_account_tab_settings" % key 2310 ) 2311 params[key] = val 2312 del params['kwargs'] 2313 # verify the required parameter 'account_id' is set 2314 if ('account_id' not in params) or (params['account_id'] is None): 2315 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2316 2317 2318 collection_formats = {} 2319 2320 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2321 path_params = {} 2322 if 'account_id' in params: 2323 path_params['accountId'] = params['account_id'] 2324 2325 query_params = {} 2326 2327 header_params = {} 2328 2329 form_params = [] 2330 local_var_files = {} 2331 2332 body_params = None 2333 # HTTP header `Accept` 2334 header_params['Accept'] = self.api_client.\ 2335 select_header_accept(['application/json']) 2336 2337 # Authentication setting 2338 auth_settings = [] 2339 2340 return self.api_client.call_api(resource_path, 'GET', 2341 path_params, 2342 query_params, 2343 header_params, 2344 body=body_params, 2345 post_params=form_params, 2346 files=local_var_files, 2347 response_type='TabAccountSettings', 2348 auth_settings=auth_settings, 2349 callback=params.get('callback'), 2350 _return_http_data_only=params.get('_return_http_data_only'), 2351 _preload_content=params.get('_preload_content', True), 2352 _request_timeout=params.get('_request_timeout'), 2353 collection_formats=collection_formats) 2354 2355 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2356 """ 2357 Get all payment gateway account for the provided accountId 2358 This method returns a list of payment gateway accounts and basic information about them. 2359 This method makes a synchronous HTTP request by default. To make an 2360 asynchronous HTTP request, please define a `callback` function 2361 to be invoked when receiving the response. 2362 >>> def callback_function(response): 2363 >>> pprint(response) 2364 >>> 2365 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2366 2367 :param callback function: The callback function 2368 for asynchronous request. (optional) 2369 :param str account_id: The external account number (int) or account ID Guid. (required) 2370 :return: PaymentGatewayAccountsInfo 2371 If the method is called asynchronously, 2372 returns the request thread. 2373 """ 2374 kwargs['_return_http_data_only'] = True 2375 if kwargs.get('callback'): 2376 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2377 else: 2378 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2379 return data 2380 2381 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2382 """ 2383 Get all payment gateway account for the provided accountId 2384 This method returns a list of payment gateway accounts and basic information about them. 2385 This method makes a synchronous HTTP request by default. To make an 2386 asynchronous HTTP request, please define a `callback` function 2387 to be invoked when receiving the response. 2388 >>> def callback_function(response): 2389 >>> pprint(response) 2390 >>> 2391 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2392 2393 :param callback function: The callback function 2394 for asynchronous request. (optional) 2395 :param str account_id: The external account number (int) or account ID Guid. (required) 2396 :return: PaymentGatewayAccountsInfo 2397 If the method is called asynchronously, 2398 returns the request thread. 2399 """ 2400 2401 all_params = ['account_id'] 2402 all_params.append('callback') 2403 all_params.append('_return_http_data_only') 2404 all_params.append('_preload_content') 2405 all_params.append('_request_timeout') 2406 2407 params = locals() 2408 for key, val in iteritems(params['kwargs']): 2409 if key not in all_params: 2410 raise TypeError( 2411 "Got an unexpected keyword argument '%s'" 2412 " to method get_all_payment_gateway_accounts" % key 2413 ) 2414 params[key] = val 2415 del params['kwargs'] 2416 # verify the required parameter 'account_id' is set 2417 if ('account_id' not in params) or (params['account_id'] is None): 2418 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 2419 2420 2421 collection_formats = {} 2422 2423 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 2424 path_params = {} 2425 if 'account_id' in params: 2426 path_params['accountId'] = params['account_id'] 2427 2428 query_params = {} 2429 2430 header_params = {} 2431 2432 form_params = [] 2433 local_var_files = {} 2434 2435 body_params = None 2436 # HTTP header `Accept` 2437 header_params['Accept'] = self.api_client.\ 2438 select_header_accept(['application/json']) 2439 2440 # Authentication setting 2441 auth_settings = [] 2442 2443 return self.api_client.call_api(resource_path, 'GET', 2444 path_params, 2445 query_params, 2446 header_params, 2447 body=body_params, 2448 post_params=form_params, 2449 files=local_var_files, 2450 response_type='PaymentGatewayAccountsInfo', 2451 auth_settings=auth_settings, 2452 callback=params.get('callback'), 2453 _return_http_data_only=params.get('_return_http_data_only'), 2454 _preload_content=params.get('_preload_content', True), 2455 _request_timeout=params.get('_request_timeout'), 2456 collection_formats=collection_formats) 2457 2458 def get_billing_charges(self, account_id, **kwargs): 2459 """ 2460 Gets list of recurring and usage charges for the account. 2461 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 2462 This method makes a synchronous HTTP request by default. To make an 2463 asynchronous HTTP request, please define a `callback` function 2464 to be invoked when receiving the response. 2465 >>> def callback_function(response): 2466 >>> pprint(response) 2467 >>> 2468 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 2469 2470 :param callback function: The callback function 2471 for asynchronous request. (optional) 2472 :param str account_id: The external account number (int) or account ID Guid. (required) 2473 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 2474 :return: BillingChargeResponse 2475 If the method is called asynchronously, 2476 returns the request thread. 2477 """ 2478 kwargs['_return_http_data_only'] = True 2479 if kwargs.get('callback'): 2480 return self.get_billing_charges_with_http_info(account_id, **kwargs) 2481 else: 2482 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 2483 return data 2484 2485 def get_billing_charges_with_http_info(self, account_id, **kwargs): 2486 """ 2487 Gets list of recurring and usage charges for the account. 2488 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 2489 This method makes a synchronous HTTP request by default. To make an 2490 asynchronous HTTP request, please define a `callback` function 2491 to be invoked when receiving the response. 2492 >>> def callback_function(response): 2493 >>> pprint(response) 2494 >>> 2495 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 2496 2497 :param callback function: The callback function 2498 for asynchronous request. (optional) 2499 :param str account_id: The external account number (int) or account ID Guid. (required) 2500 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 2501 :return: BillingChargeResponse 2502 If the method is called asynchronously, 2503 returns the request thread. 2504 """ 2505 2506 all_params = ['account_id', 'include_charges'] 2507 all_params.append('callback') 2508 all_params.append('_return_http_data_only') 2509 all_params.append('_preload_content') 2510 all_params.append('_request_timeout') 2511 2512 params = locals() 2513 for key, val in iteritems(params['kwargs']): 2514 if key not in all_params: 2515 raise TypeError( 2516 "Got an unexpected keyword argument '%s'" 2517 " to method get_billing_charges" % key 2518 ) 2519 params[key] = val 2520 del params['kwargs'] 2521 # verify the required parameter 'account_id' is set 2522 if ('account_id' not in params) or (params['account_id'] is None): 2523 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 2524 2525 2526 collection_formats = {} 2527 2528 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 2529 path_params = {} 2530 if 'account_id' in params: 2531 path_params['accountId'] = params['account_id'] 2532 2533 query_params = {} 2534 if 'include_charges' in params: 2535 query_params['include_charges'] = params['include_charges'] 2536 2537 header_params = {} 2538 2539 form_params = [] 2540 local_var_files = {} 2541 2542 body_params = None 2543 # HTTP header `Accept` 2544 header_params['Accept'] = self.api_client.\ 2545 select_header_accept(['application/json']) 2546 2547 # Authentication setting 2548 auth_settings = [] 2549 2550 return self.api_client.call_api(resource_path, 'GET', 2551 path_params, 2552 query_params, 2553 header_params, 2554 body=body_params, 2555 post_params=form_params, 2556 files=local_var_files, 2557 response_type='BillingChargeResponse', 2558 auth_settings=auth_settings, 2559 callback=params.get('callback'), 2560 _return_http_data_only=params.get('_return_http_data_only'), 2561 _preload_content=params.get('_preload_content', True), 2562 _request_timeout=params.get('_request_timeout'), 2563 collection_formats=collection_formats) 2564 2565 def get_brand(self, account_id, brand_id, **kwargs): 2566 """ 2567 Get information for a specific brand. 2568 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2569 This method makes a synchronous HTTP request by default. To make an 2570 asynchronous HTTP request, please define a `callback` function 2571 to be invoked when receiving the response. 2572 >>> def callback_function(response): 2573 >>> pprint(response) 2574 >>> 2575 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 2576 2577 :param callback function: The callback function 2578 for asynchronous request. (optional) 2579 :param str account_id: The external account number (int) or account ID Guid. (required) 2580 :param str brand_id: The unique identifier of a brand. (required) 2581 :param str include_external_references: 2582 :param str include_logos: 2583 :return: Brand 2584 If the method is called asynchronously, 2585 returns the request thread. 2586 """ 2587 kwargs['_return_http_data_only'] = True 2588 if kwargs.get('callback'): 2589 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 2590 else: 2591 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 2592 return data 2593 2594 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 2595 """ 2596 Get information for a specific brand. 2597 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2598 This method makes a synchronous HTTP request by default. To make an 2599 asynchronous HTTP request, please define a `callback` function 2600 to be invoked when receiving the response. 2601 >>> def callback_function(response): 2602 >>> pprint(response) 2603 >>> 2604 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 2605 2606 :param callback function: The callback function 2607 for asynchronous request. (optional) 2608 :param str account_id: The external account number (int) or account ID Guid. (required) 2609 :param str brand_id: The unique identifier of a brand. (required) 2610 :param str include_external_references: 2611 :param str include_logos: 2612 :return: Brand 2613 If the method is called asynchronously, 2614 returns the request thread. 2615 """ 2616 2617 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 2618 all_params.append('callback') 2619 all_params.append('_return_http_data_only') 2620 all_params.append('_preload_content') 2621 all_params.append('_request_timeout') 2622 2623 params = locals() 2624 for key, val in iteritems(params['kwargs']): 2625 if key not in all_params: 2626 raise TypeError( 2627 "Got an unexpected keyword argument '%s'" 2628 " to method get_brand" % key 2629 ) 2630 params[key] = val 2631 del params['kwargs'] 2632 # verify the required parameter 'account_id' is set 2633 if ('account_id' not in params) or (params['account_id'] is None): 2634 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 2635 # verify the required parameter 'brand_id' is set 2636 if ('brand_id' not in params) or (params['brand_id'] is None): 2637 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 2638 2639 2640 collection_formats = {} 2641 2642 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 2643 path_params = {} 2644 if 'account_id' in params: 2645 path_params['accountId'] = params['account_id'] 2646 if 'brand_id' in params: 2647 path_params['brandId'] = params['brand_id'] 2648 2649 query_params = {} 2650 if 'include_external_references' in params: 2651 query_params['include_external_references'] = params['include_external_references'] 2652 if 'include_logos' in params: 2653 query_params['include_logos'] = params['include_logos'] 2654 2655 header_params = {} 2656 2657 form_params = [] 2658 local_var_files = {} 2659 2660 body_params = None 2661 # HTTP header `Accept` 2662 header_params['Accept'] = self.api_client.\ 2663 select_header_accept(['application/json']) 2664 2665 # Authentication setting 2666 auth_settings = [] 2667 2668 return self.api_client.call_api(resource_path, 'GET', 2669 path_params, 2670 query_params, 2671 header_params, 2672 body=body_params, 2673 post_params=form_params, 2674 files=local_var_files, 2675 response_type='Brand', 2676 auth_settings=auth_settings, 2677 callback=params.get('callback'), 2678 _return_http_data_only=params.get('_return_http_data_only'), 2679 _preload_content=params.get('_preload_content', True), 2680 _request_timeout=params.get('_request_timeout'), 2681 collection_formats=collection_formats) 2682 2683 def get_brand_export_file(self, account_id, brand_id, **kwargs): 2684 """ 2685 Export a specific brand. 2686 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2687 This method makes a synchronous HTTP request by default. To make an 2688 asynchronous HTTP request, please define a `callback` function 2689 to be invoked when receiving the response. 2690 >>> def callback_function(response): 2691 >>> pprint(response) 2692 >>> 2693 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 2694 2695 :param callback function: The callback function 2696 for asynchronous request. (optional) 2697 :param str account_id: The external account number (int) or account ID Guid. (required) 2698 :param str brand_id: The unique identifier of a brand. (required) 2699 :return: None 2700 If the method is called asynchronously, 2701 returns the request thread. 2702 """ 2703 kwargs['_return_http_data_only'] = True 2704 if kwargs.get('callback'): 2705 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 2706 else: 2707 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 2708 return data 2709 2710 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 2711 """ 2712 Export a specific brand. 2713 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2714 This method makes a synchronous HTTP request by default. To make an 2715 asynchronous HTTP request, please define a `callback` function 2716 to be invoked when receiving the response. 2717 >>> def callback_function(response): 2718 >>> pprint(response) 2719 >>> 2720 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 2721 2722 :param callback function: The callback function 2723 for asynchronous request. (optional) 2724 :param str account_id: The external account number (int) or account ID Guid. (required) 2725 :param str brand_id: The unique identifier of a brand. (required) 2726 :return: None 2727 If the method is called asynchronously, 2728 returns the request thread. 2729 """ 2730 2731 all_params = ['account_id', 'brand_id'] 2732 all_params.append('callback') 2733 all_params.append('_return_http_data_only') 2734 all_params.append('_preload_content') 2735 all_params.append('_request_timeout') 2736 2737 params = locals() 2738 for key, val in iteritems(params['kwargs']): 2739 if key not in all_params: 2740 raise TypeError( 2741 "Got an unexpected keyword argument '%s'" 2742 " to method get_brand_export_file" % key 2743 ) 2744 params[key] = val 2745 del params['kwargs'] 2746 # verify the required parameter 'account_id' is set 2747 if ('account_id' not in params) or (params['account_id'] is None): 2748 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 2749 # verify the required parameter 'brand_id' is set 2750 if ('brand_id' not in params) or (params['brand_id'] is None): 2751 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 2752 2753 2754 collection_formats = {} 2755 2756 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 2757 path_params = {} 2758 if 'account_id' in params: 2759 path_params['accountId'] = params['account_id'] 2760 if 'brand_id' in params: 2761 path_params['brandId'] = params['brand_id'] 2762 2763 query_params = {} 2764 2765 header_params = {} 2766 2767 form_params = [] 2768 local_var_files = {} 2769 2770 body_params = None 2771 # HTTP header `Accept` 2772 header_params['Accept'] = self.api_client.\ 2773 select_header_accept(['application/json']) 2774 2775 # Authentication setting 2776 auth_settings = [] 2777 2778 return self.api_client.call_api(resource_path, 'GET', 2779 path_params, 2780 query_params, 2781 header_params, 2782 body=body_params, 2783 post_params=form_params, 2784 files=local_var_files, 2785 response_type=None, 2786 auth_settings=auth_settings, 2787 callback=params.get('callback'), 2788 _return_http_data_only=params.get('_return_http_data_only'), 2789 _preload_content=params.get('_preload_content', True), 2790 _request_timeout=params.get('_request_timeout'), 2791 collection_formats=collection_formats) 2792 2793 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 2794 """ 2795 Obtains the specified image for a brand. 2796 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2797 This method makes a synchronous HTTP request by default. To make an 2798 asynchronous HTTP request, please define a `callback` function 2799 to be invoked when receiving the response. 2800 >>> def callback_function(response): 2801 >>> pprint(response) 2802 >>> 2803 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 2804 2805 :param callback function: The callback function 2806 for asynchronous request. (optional) 2807 :param str account_id: The external account number (int) or account ID Guid. (required) 2808 :param str brand_id: The unique identifier of a brand. (required) 2809 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 2810 :return: file 2811 If the method is called asynchronously, 2812 returns the request thread. 2813 """ 2814 kwargs['_return_http_data_only'] = True 2815 if kwargs.get('callback'): 2816 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 2817 else: 2818 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 2819 return data 2820 2821 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 2822 """ 2823 Obtains the specified image for a brand. 2824 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2825 This method makes a synchronous HTTP request by default. To make an 2826 asynchronous HTTP request, please define a `callback` function 2827 to be invoked when receiving the response. 2828 >>> def callback_function(response): 2829 >>> pprint(response) 2830 >>> 2831 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 2832 2833 :param callback function: The callback function 2834 for asynchronous request. (optional) 2835 :param str account_id: The external account number (int) or account ID Guid. (required) 2836 :param str brand_id: The unique identifier of a brand. (required) 2837 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 2838 :return: file 2839 If the method is called asynchronously, 2840 returns the request thread. 2841 """ 2842 2843 all_params = ['account_id', 'brand_id', 'logo_type'] 2844 all_params.append('callback') 2845 all_params.append('_return_http_data_only') 2846 all_params.append('_preload_content') 2847 all_params.append('_request_timeout') 2848 2849 params = locals() 2850 for key, val in iteritems(params['kwargs']): 2851 if key not in all_params: 2852 raise TypeError( 2853 "Got an unexpected keyword argument '%s'" 2854 " to method get_brand_logo_by_type" % key 2855 ) 2856 params[key] = val 2857 del params['kwargs'] 2858 # verify the required parameter 'account_id' is set 2859 if ('account_id' not in params) or (params['account_id'] is None): 2860 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 2861 # verify the required parameter 'brand_id' is set 2862 if ('brand_id' not in params) or (params['brand_id'] is None): 2863 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 2864 # verify the required parameter 'logo_type' is set 2865 if ('logo_type' not in params) or (params['logo_type'] is None): 2866 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 2867 2868 2869 collection_formats = {} 2870 2871 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 2872 path_params = {} 2873 if 'account_id' in params: 2874 path_params['accountId'] = params['account_id'] 2875 if 'brand_id' in params: 2876 path_params['brandId'] = params['brand_id'] 2877 if 'logo_type' in params: 2878 path_params['logoType'] = params['logo_type'] 2879 2880 query_params = {} 2881 2882 header_params = {} 2883 2884 form_params = [] 2885 local_var_files = {} 2886 2887 body_params = None 2888 # HTTP header `Accept` 2889 header_params['Accept'] = self.api_client.\ 2890 select_header_accept(['image/png']) 2891 2892 # Authentication setting 2893 auth_settings = [] 2894 2895 return self.api_client.call_api(resource_path, 'GET', 2896 path_params, 2897 query_params, 2898 header_params, 2899 body=body_params, 2900 post_params=form_params, 2901 files=local_var_files, 2902 response_type='file', 2903 auth_settings=auth_settings, 2904 callback=params.get('callback'), 2905 _return_http_data_only=params.get('_return_http_data_only'), 2906 _preload_content=params.get('_preload_content', True), 2907 _request_timeout=params.get('_request_timeout'), 2908 collection_formats=collection_formats) 2909 2910 def get_brand_resources(self, account_id, brand_id, **kwargs): 2911 """ 2912 Returns the specified account's list of branding resources (metadata). 2913 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2914 This method makes a synchronous HTTP request by default. To make an 2915 asynchronous HTTP request, please define a `callback` function 2916 to be invoked when receiving the response. 2917 >>> def callback_function(response): 2918 >>> pprint(response) 2919 >>> 2920 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 2921 2922 :param callback function: The callback function 2923 for asynchronous request. (optional) 2924 :param str account_id: The external account number (int) or account ID Guid. (required) 2925 :param str brand_id: The unique identifier of a brand. (required) 2926 :return: BrandResourcesList 2927 If the method is called asynchronously, 2928 returns the request thread. 2929 """ 2930 kwargs['_return_http_data_only'] = True 2931 if kwargs.get('callback'): 2932 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 2933 else: 2934 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 2935 return data 2936 2937 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 2938 """ 2939 Returns the specified account's list of branding resources (metadata). 2940 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2941 This method makes a synchronous HTTP request by default. To make an 2942 asynchronous HTTP request, please define a `callback` function 2943 to be invoked when receiving the response. 2944 >>> def callback_function(response): 2945 >>> pprint(response) 2946 >>> 2947 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 2948 2949 :param callback function: The callback function 2950 for asynchronous request. (optional) 2951 :param str account_id: The external account number (int) or account ID Guid. (required) 2952 :param str brand_id: The unique identifier of a brand. (required) 2953 :return: BrandResourcesList 2954 If the method is called asynchronously, 2955 returns the request thread. 2956 """ 2957 2958 all_params = ['account_id', 'brand_id'] 2959 all_params.append('callback') 2960 all_params.append('_return_http_data_only') 2961 all_params.append('_preload_content') 2962 all_params.append('_request_timeout') 2963 2964 params = locals() 2965 for key, val in iteritems(params['kwargs']): 2966 if key not in all_params: 2967 raise TypeError( 2968 "Got an unexpected keyword argument '%s'" 2969 " to method get_brand_resources" % key 2970 ) 2971 params[key] = val 2972 del params['kwargs'] 2973 # verify the required parameter 'account_id' is set 2974 if ('account_id' not in params) or (params['account_id'] is None): 2975 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 2976 # verify the required parameter 'brand_id' is set 2977 if ('brand_id' not in params) or (params['brand_id'] is None): 2978 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 2979 2980 2981 collection_formats = {} 2982 2983 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 2984 path_params = {} 2985 if 'account_id' in params: 2986 path_params['accountId'] = params['account_id'] 2987 if 'brand_id' in params: 2988 path_params['brandId'] = params['brand_id'] 2989 2990 query_params = {} 2991 2992 header_params = {} 2993 2994 form_params = [] 2995 local_var_files = {} 2996 2997 body_params = None 2998 # HTTP header `Accept` 2999 header_params['Accept'] = self.api_client.\ 3000 select_header_accept(['application/json']) 3001 3002 # Authentication setting 3003 auth_settings = [] 3004 3005 return self.api_client.call_api(resource_path, 'GET', 3006 path_params, 3007 query_params, 3008 header_params, 3009 body=body_params, 3010 post_params=form_params, 3011 files=local_var_files, 3012 response_type='BrandResourcesList', 3013 auth_settings=auth_settings, 3014 callback=params.get('callback'), 3015 _return_http_data_only=params.get('_return_http_data_only'), 3016 _preload_content=params.get('_preload_content', True), 3017 _request_timeout=params.get('_request_timeout'), 3018 collection_formats=collection_formats) 3019 3020 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3021 """ 3022 Returns the specified branding resource file. 3023 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3024 This method makes a synchronous HTTP request by default. To make an 3025 asynchronous HTTP request, please define a `callback` function 3026 to be invoked when receiving the response. 3027 >>> def callback_function(response): 3028 >>> pprint(response) 3029 >>> 3030 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3031 3032 :param callback function: The callback function 3033 for asynchronous request. (optional) 3034 :param str account_id: The external account number (int) or account ID Guid. (required) 3035 :param str brand_id: The unique identifier of a brand. (required) 3036 :param str resource_content_type: (required) 3037 :param str langcode: 3038 :param str return_master: 3039 :return: None 3040 If the method is called asynchronously, 3041 returns the request thread. 3042 """ 3043 kwargs['_return_http_data_only'] = True 3044 if kwargs.get('callback'): 3045 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3046 else: 3047 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3048 return data 3049 3050 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3051 """ 3052 Returns the specified branding resource file. 3053 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3054 This method makes a synchronous HTTP request by default. To make an 3055 asynchronous HTTP request, please define a `callback` function 3056 to be invoked when receiving the response. 3057 >>> def callback_function(response): 3058 >>> pprint(response) 3059 >>> 3060 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3061 3062 :param callback function: The callback function 3063 for asynchronous request. (optional) 3064 :param str account_id: The external account number (int) or account ID Guid. (required) 3065 :param str brand_id: The unique identifier of a brand. (required) 3066 :param str resource_content_type: (required) 3067 :param str langcode: 3068 :param str return_master: 3069 :return: None 3070 If the method is called asynchronously, 3071 returns the request thread. 3072 """ 3073 3074 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3075 all_params.append('callback') 3076 all_params.append('_return_http_data_only') 3077 all_params.append('_preload_content') 3078 all_params.append('_request_timeout') 3079 3080 params = locals() 3081 for key, val in iteritems(params['kwargs']): 3082 if key not in all_params: 3083 raise TypeError( 3084 "Got an unexpected keyword argument '%s'" 3085 " to method get_brand_resources_by_content_type" % key 3086 ) 3087 params[key] = val 3088 del params['kwargs'] 3089 # verify the required parameter 'account_id' is set 3090 if ('account_id' not in params) or (params['account_id'] is None): 3091 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3092 # verify the required parameter 'brand_id' is set 3093 if ('brand_id' not in params) or (params['brand_id'] is None): 3094 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3095 # verify the required parameter 'resource_content_type' is set 3096 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3097 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3098 3099 3100 collection_formats = {} 3101 3102 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3103 path_params = {} 3104 if 'account_id' in params: 3105 path_params['accountId'] = params['account_id'] 3106 if 'brand_id' in params: 3107 path_params['brandId'] = params['brand_id'] 3108 if 'resource_content_type' in params: 3109 path_params['resourceContentType'] = params['resource_content_type'] 3110 3111 query_params = {} 3112 if 'langcode' in params: 3113 query_params['langcode'] = params['langcode'] 3114 if 'return_master' in params: 3115 query_params['return_master'] = params['return_master'] 3116 3117 header_params = {} 3118 3119 form_params = [] 3120 local_var_files = {} 3121 3122 body_params = None 3123 # HTTP header `Accept` 3124 header_params['Accept'] = self.api_client.\ 3125 select_header_accept(['application/json']) 3126 3127 # Authentication setting 3128 auth_settings = [] 3129 3130 return self.api_client.call_api(resource_path, 'GET', 3131 path_params, 3132 query_params, 3133 header_params, 3134 body=body_params, 3135 post_params=form_params, 3136 files=local_var_files, 3137 response_type=None, 3138 auth_settings=auth_settings, 3139 callback=params.get('callback'), 3140 _return_http_data_only=params.get('_return_http_data_only'), 3141 _preload_content=params.get('_preload_content', True), 3142 _request_timeout=params.get('_request_timeout'), 3143 collection_formats=collection_formats) 3144 3145 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3146 """ 3147 Gets the Electronic Record and Signature Disclosure. 3148 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3149 This method makes a synchronous HTTP request by default. To make an 3150 asynchronous HTTP request, please define a `callback` function 3151 to be invoked when receiving the response. 3152 >>> def callback_function(response): 3153 >>> pprint(response) 3154 >>> 3155 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3156 3157 :param callback function: The callback function 3158 for asynchronous request. (optional) 3159 :param str account_id: The external account number (int) or account ID Guid. (required) 3160 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3161 :return: ConsumerDisclosure 3162 If the method is called asynchronously, 3163 returns the request thread. 3164 """ 3165 kwargs['_return_http_data_only'] = True 3166 if kwargs.get('callback'): 3167 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3168 else: 3169 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3170 return data 3171 3172 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3173 """ 3174 Gets the Electronic Record and Signature Disclosure. 3175 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3176 This method makes a synchronous HTTP request by default. To make an 3177 asynchronous HTTP request, please define a `callback` function 3178 to be invoked when receiving the response. 3179 >>> def callback_function(response): 3180 >>> pprint(response) 3181 >>> 3182 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3183 3184 :param callback function: The callback function 3185 for asynchronous request. (optional) 3186 :param str account_id: The external account number (int) or account ID Guid. (required) 3187 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3188 :return: ConsumerDisclosure 3189 If the method is called asynchronously, 3190 returns the request thread. 3191 """ 3192 3193 all_params = ['account_id', 'lang_code'] 3194 all_params.append('callback') 3195 all_params.append('_return_http_data_only') 3196 all_params.append('_preload_content') 3197 all_params.append('_request_timeout') 3198 3199 params = locals() 3200 for key, val in iteritems(params['kwargs']): 3201 if key not in all_params: 3202 raise TypeError( 3203 "Got an unexpected keyword argument '%s'" 3204 " to method get_consumer_disclosure" % key 3205 ) 3206 params[key] = val 3207 del params['kwargs'] 3208 # verify the required parameter 'account_id' is set 3209 if ('account_id' not in params) or (params['account_id'] is None): 3210 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3211 # verify the required parameter 'lang_code' is set 3212 if ('lang_code' not in params) or (params['lang_code'] is None): 3213 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3214 3215 3216 collection_formats = {} 3217 3218 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3219 path_params = {} 3220 if 'account_id' in params: 3221 path_params['accountId'] = params['account_id'] 3222 if 'lang_code' in params: 3223 path_params['langCode'] = params['lang_code'] 3224 3225 query_params = {} 3226 3227 header_params = {} 3228 3229 form_params = [] 3230 local_var_files = {} 3231 3232 body_params = None 3233 # HTTP header `Accept` 3234 header_params['Accept'] = self.api_client.\ 3235 select_header_accept(['application/json']) 3236 3237 # Authentication setting 3238 auth_settings = [] 3239 3240 return self.api_client.call_api(resource_path, 'GET', 3241 path_params, 3242 query_params, 3243 header_params, 3244 body=body_params, 3245 post_params=form_params, 3246 files=local_var_files, 3247 response_type='ConsumerDisclosure', 3248 auth_settings=auth_settings, 3249 callback=params.get('callback'), 3250 _return_http_data_only=params.get('_return_http_data_only'), 3251 _preload_content=params.get('_preload_content', True), 3252 _request_timeout=params.get('_request_timeout'), 3253 collection_formats=collection_formats) 3254 3255 def get_consumer_disclosure_default(self, account_id, **kwargs): 3256 """ 3257 Gets the Electronic Record and Signature Disclosure for the account. 3258 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 3259 This method makes a synchronous HTTP request by default. To make an 3260 asynchronous HTTP request, please define a `callback` function 3261 to be invoked when receiving the response. 3262 >>> def callback_function(response): 3263 >>> pprint(response) 3264 >>> 3265 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3266 3267 :param callback function: The callback function 3268 for asynchronous request. (optional) 3269 :param str account_id: The external account number (int) or account ID Guid. (required) 3270 :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 3271 :return: ConsumerDisclosure 3272 If the method is called asynchronously, 3273 returns the request thread. 3274 """ 3275 kwargs['_return_http_data_only'] = True 3276 if kwargs.get('callback'): 3277 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3278 else: 3279 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3280 return data 3281 3282 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3283 """ 3284 Gets the Electronic Record and Signature Disclosure for the account. 3285 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 3286 This method makes a synchronous HTTP request by default. To make an 3287 asynchronous HTTP request, please define a `callback` function 3288 to be invoked when receiving the response. 3289 >>> def callback_function(response): 3290 >>> pprint(response) 3291 >>> 3292 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3293 3294 :param callback function: The callback function 3295 for asynchronous request. (optional) 3296 :param str account_id: The external account number (int) or account ID Guid. (required) 3297 :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 3298 :return: ConsumerDisclosure 3299 If the method is called asynchronously, 3300 returns the request thread. 3301 """ 3302 3303 all_params = ['account_id', 'lang_code'] 3304 all_params.append('callback') 3305 all_params.append('_return_http_data_only') 3306 all_params.append('_preload_content') 3307 all_params.append('_request_timeout') 3308 3309 params = locals() 3310 for key, val in iteritems(params['kwargs']): 3311 if key not in all_params: 3312 raise TypeError( 3313 "Got an unexpected keyword argument '%s'" 3314 " to method get_consumer_disclosure_default" % key 3315 ) 3316 params[key] = val 3317 del params['kwargs'] 3318 # verify the required parameter 'account_id' is set 3319 if ('account_id' not in params) or (params['account_id'] is None): 3320 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3321 3322 3323 collection_formats = {} 3324 3325 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3326 path_params = {} 3327 if 'account_id' in params: 3328 path_params['accountId'] = params['account_id'] 3329 3330 query_params = {} 3331 if 'lang_code' in params: 3332 query_params['langCode'] = params['lang_code'] 3333 3334 header_params = {} 3335 3336 form_params = [] 3337 local_var_files = {} 3338 3339 body_params = None 3340 # HTTP header `Accept` 3341 header_params['Accept'] = self.api_client.\ 3342 select_header_accept(['application/json']) 3343 3344 # Authentication setting 3345 auth_settings = [] 3346 3347 return self.api_client.call_api(resource_path, 'GET', 3348 path_params, 3349 query_params, 3350 header_params, 3351 body=body_params, 3352 post_params=form_params, 3353 files=local_var_files, 3354 response_type='ConsumerDisclosure', 3355 auth_settings=auth_settings, 3356 callback=params.get('callback'), 3357 _return_http_data_only=params.get('_return_http_data_only'), 3358 _preload_content=params.get('_preload_content', True), 3359 _request_timeout=params.get('_request_timeout'), 3360 collection_formats=collection_formats) 3361 3362 def get_e_note_configuration(self, account_id, **kwargs): 3363 """ 3364 Returns the configuration information for the eNote eOriginal integration. 3365 3366 This method makes a synchronous HTTP request by default. To make an 3367 asynchronous HTTP request, please define a `callback` function 3368 to be invoked when receiving the response. 3369 >>> def callback_function(response): 3370 >>> pprint(response) 3371 >>> 3372 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3373 3374 :param callback function: The callback function 3375 for asynchronous request. (optional) 3376 :param str account_id: The external account number (int) or account ID Guid. (required) 3377 :return: ENoteConfiguration 3378 If the method is called asynchronously, 3379 returns the request thread. 3380 """ 3381 kwargs['_return_http_data_only'] = True 3382 if kwargs.get('callback'): 3383 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3384 else: 3385 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3386 return data 3387 3388 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3389 """ 3390 Returns the configuration information for the eNote eOriginal integration. 3391 3392 This method makes a synchronous HTTP request by default. To make an 3393 asynchronous HTTP request, please define a `callback` function 3394 to be invoked when receiving the response. 3395 >>> def callback_function(response): 3396 >>> pprint(response) 3397 >>> 3398 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3399 3400 :param callback function: The callback function 3401 for asynchronous request. (optional) 3402 :param str account_id: The external account number (int) or account ID Guid. (required) 3403 :return: ENoteConfiguration 3404 If the method is called asynchronously, 3405 returns the request thread. 3406 """ 3407 3408 all_params = ['account_id'] 3409 all_params.append('callback') 3410 all_params.append('_return_http_data_only') 3411 all_params.append('_preload_content') 3412 all_params.append('_request_timeout') 3413 3414 params = locals() 3415 for key, val in iteritems(params['kwargs']): 3416 if key not in all_params: 3417 raise TypeError( 3418 "Got an unexpected keyword argument '%s'" 3419 " to method get_e_note_configuration" % key 3420 ) 3421 params[key] = val 3422 del params['kwargs'] 3423 # verify the required parameter 'account_id' is set 3424 if ('account_id' not in params) or (params['account_id'] is None): 3425 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 3426 3427 3428 collection_formats = {} 3429 3430 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 3431 path_params = {} 3432 if 'account_id' in params: 3433 path_params['accountId'] = params['account_id'] 3434 3435 query_params = {} 3436 3437 header_params = {} 3438 3439 form_params = [] 3440 local_var_files = {} 3441 3442 body_params = None 3443 # HTTP header `Accept` 3444 header_params['Accept'] = self.api_client.\ 3445 select_header_accept(['application/json']) 3446 3447 # Authentication setting 3448 auth_settings = [] 3449 3450 return self.api_client.call_api(resource_path, 'GET', 3451 path_params, 3452 query_params, 3453 header_params, 3454 body=body_params, 3455 post_params=form_params, 3456 files=local_var_files, 3457 response_type='ENoteConfiguration', 3458 auth_settings=auth_settings, 3459 callback=params.get('callback'), 3460 _return_http_data_only=params.get('_return_http_data_only'), 3461 _preload_content=params.get('_preload_content', True), 3462 _request_timeout=params.get('_request_timeout'), 3463 collection_formats=collection_formats) 3464 3465 def get_envelope_purge_configuration(self, account_id, **kwargs): 3466 """ 3467 Select envelope purge configuration. 3468 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 3469 This method makes a synchronous HTTP request by default. To make an 3470 asynchronous HTTP request, please define a `callback` function 3471 to be invoked when receiving the response. 3472 >>> def callback_function(response): 3473 >>> pprint(response) 3474 >>> 3475 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 3476 3477 :param callback function: The callback function 3478 for asynchronous request. (optional) 3479 :param str account_id: The external account number (int) or account ID Guid. (required) 3480 :return: EnvelopePurgeConfiguration 3481 If the method is called asynchronously, 3482 returns the request thread. 3483 """ 3484 kwargs['_return_http_data_only'] = True 3485 if kwargs.get('callback'): 3486 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 3487 else: 3488 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 3489 return data 3490 3491 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 3492 """ 3493 Select envelope purge configuration. 3494 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 3495 This method makes a synchronous HTTP request by default. To make an 3496 asynchronous HTTP request, please define a `callback` function 3497 to be invoked when receiving the response. 3498 >>> def callback_function(response): 3499 >>> pprint(response) 3500 >>> 3501 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 3502 3503 :param callback function: The callback function 3504 for asynchronous request. (optional) 3505 :param str account_id: The external account number (int) or account ID Guid. (required) 3506 :return: EnvelopePurgeConfiguration 3507 If the method is called asynchronously, 3508 returns the request thread. 3509 """ 3510 3511 all_params = ['account_id'] 3512 all_params.append('callback') 3513 all_params.append('_return_http_data_only') 3514 all_params.append('_preload_content') 3515 all_params.append('_request_timeout') 3516 3517 params = locals() 3518 for key, val in iteritems(params['kwargs']): 3519 if key not in all_params: 3520 raise TypeError( 3521 "Got an unexpected keyword argument '%s'" 3522 " to method get_envelope_purge_configuration" % key 3523 ) 3524 params[key] = val 3525 del params['kwargs'] 3526 # verify the required parameter 'account_id' is set 3527 if ('account_id' not in params) or (params['account_id'] is None): 3528 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 3529 3530 3531 collection_formats = {} 3532 3533 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 3534 path_params = {} 3535 if 'account_id' in params: 3536 path_params['accountId'] = params['account_id'] 3537 3538 query_params = {} 3539 3540 header_params = {} 3541 3542 form_params = [] 3543 local_var_files = {} 3544 3545 body_params = None 3546 # HTTP header `Accept` 3547 header_params['Accept'] = self.api_client.\ 3548 select_header_accept(['application/json']) 3549 3550 # Authentication setting 3551 auth_settings = [] 3552 3553 return self.api_client.call_api(resource_path, 'GET', 3554 path_params, 3555 query_params, 3556 header_params, 3557 body=body_params, 3558 post_params=form_params, 3559 files=local_var_files, 3560 response_type='EnvelopePurgeConfiguration', 3561 auth_settings=auth_settings, 3562 callback=params.get('callback'), 3563 _return_http_data_only=params.get('_return_http_data_only'), 3564 _preload_content=params.get('_preload_content', True), 3565 _request_timeout=params.get('_request_timeout'), 3566 collection_formats=collection_formats) 3567 3568 def get_favorite_templates(self, account_id, **kwargs): 3569 """ 3570 Retrieves the list of favorited templates for this caller 3571 3572 This method makes a synchronous HTTP request by default. To make an 3573 asynchronous HTTP request, please define a `callback` function 3574 to be invoked when receiving the response. 3575 >>> def callback_function(response): 3576 >>> pprint(response) 3577 >>> 3578 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 3579 3580 :param callback function: The callback function 3581 for asynchronous request. (optional) 3582 :param str account_id: The external account number (int) or account ID Guid. (required) 3583 :return: FavoriteTemplatesInfo 3584 If the method is called asynchronously, 3585 returns the request thread. 3586 """ 3587 kwargs['_return_http_data_only'] = True 3588 if kwargs.get('callback'): 3589 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 3590 else: 3591 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 3592 return data 3593 3594 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 3595 """ 3596 Retrieves the list of favorited templates for this caller 3597 3598 This method makes a synchronous HTTP request by default. To make an 3599 asynchronous HTTP request, please define a `callback` function 3600 to be invoked when receiving the response. 3601 >>> def callback_function(response): 3602 >>> pprint(response) 3603 >>> 3604 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 3605 3606 :param callback function: The callback function 3607 for asynchronous request. (optional) 3608 :param str account_id: The external account number (int) or account ID Guid. (required) 3609 :return: FavoriteTemplatesInfo 3610 If the method is called asynchronously, 3611 returns the request thread. 3612 """ 3613 3614 all_params = ['account_id'] 3615 all_params.append('callback') 3616 all_params.append('_return_http_data_only') 3617 all_params.append('_preload_content') 3618 all_params.append('_request_timeout') 3619 3620 params = locals() 3621 for key, val in iteritems(params['kwargs']): 3622 if key not in all_params: 3623 raise TypeError( 3624 "Got an unexpected keyword argument '%s'" 3625 " to method get_favorite_templates" % key 3626 ) 3627 params[key] = val 3628 del params['kwargs'] 3629 # verify the required parameter 'account_id' is set 3630 if ('account_id' not in params) or (params['account_id'] is None): 3631 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 3632 3633 3634 collection_formats = {} 3635 3636 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 3637 path_params = {} 3638 if 'account_id' in params: 3639 path_params['accountId'] = params['account_id'] 3640 3641 query_params = {} 3642 3643 header_params = {} 3644 3645 form_params = [] 3646 local_var_files = {} 3647 3648 body_params = None 3649 # HTTP header `Accept` 3650 header_params['Accept'] = self.api_client.\ 3651 select_header_accept(['application/json']) 3652 3653 # Authentication setting 3654 auth_settings = [] 3655 3656 return self.api_client.call_api(resource_path, 'GET', 3657 path_params, 3658 query_params, 3659 header_params, 3660 body=body_params, 3661 post_params=form_params, 3662 files=local_var_files, 3663 response_type='FavoriteTemplatesInfo', 3664 auth_settings=auth_settings, 3665 callback=params.get('callback'), 3666 _return_http_data_only=params.get('_return_http_data_only'), 3667 _preload_content=params.get('_preload_content', True), 3668 _request_timeout=params.get('_request_timeout'), 3669 collection_formats=collection_formats) 3670 3671 def get_notification_defaults(self, account_id, **kwargs): 3672 """ 3673 Returns default user level settings for a specified account 3674 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 3675 This method makes a synchronous HTTP request by default. To make an 3676 asynchronous HTTP request, please define a `callback` function 3677 to be invoked when receiving the response. 3678 >>> def callback_function(response): 3679 >>> pprint(response) 3680 >>> 3681 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 3682 3683 :param callback function: The callback function 3684 for asynchronous request. (optional) 3685 :param str account_id: The external account number (int) or account ID Guid. (required) 3686 :return: NotificationDefaults 3687 If the method is called asynchronously, 3688 returns the request thread. 3689 """ 3690 kwargs['_return_http_data_only'] = True 3691 if kwargs.get('callback'): 3692 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 3693 else: 3694 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 3695 return data 3696 3697 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 3698 """ 3699 Returns default user level settings for a specified account 3700 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 3701 This method makes a synchronous HTTP request by default. To make an 3702 asynchronous HTTP request, please define a `callback` function 3703 to be invoked when receiving the response. 3704 >>> def callback_function(response): 3705 >>> pprint(response) 3706 >>> 3707 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 3708 3709 :param callback function: The callback function 3710 for asynchronous request. (optional) 3711 :param str account_id: The external account number (int) or account ID Guid. (required) 3712 :return: NotificationDefaults 3713 If the method is called asynchronously, 3714 returns the request thread. 3715 """ 3716 3717 all_params = ['account_id'] 3718 all_params.append('callback') 3719 all_params.append('_return_http_data_only') 3720 all_params.append('_preload_content') 3721 all_params.append('_request_timeout') 3722 3723 params = locals() 3724 for key, val in iteritems(params['kwargs']): 3725 if key not in all_params: 3726 raise TypeError( 3727 "Got an unexpected keyword argument '%s'" 3728 " to method get_notification_defaults" % key 3729 ) 3730 params[key] = val 3731 del params['kwargs'] 3732 # verify the required parameter 'account_id' is set 3733 if ('account_id' not in params) or (params['account_id'] is None): 3734 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 3735 3736 3737 collection_formats = {} 3738 3739 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 3740 path_params = {} 3741 if 'account_id' in params: 3742 path_params['accountId'] = params['account_id'] 3743 3744 query_params = {} 3745 3746 header_params = {} 3747 3748 form_params = [] 3749 local_var_files = {} 3750 3751 body_params = None 3752 # HTTP header `Accept` 3753 header_params['Accept'] = self.api_client.\ 3754 select_header_accept(['application/json']) 3755 3756 # Authentication setting 3757 auth_settings = [] 3758 3759 return self.api_client.call_api(resource_path, 'GET', 3760 path_params, 3761 query_params, 3762 header_params, 3763 body=body_params, 3764 post_params=form_params, 3765 files=local_var_files, 3766 response_type='NotificationDefaults', 3767 auth_settings=auth_settings, 3768 callback=params.get('callback'), 3769 _return_http_data_only=params.get('_return_http_data_only'), 3770 _preload_content=params.get('_preload_content', True), 3771 _request_timeout=params.get('_request_timeout'), 3772 collection_formats=collection_formats) 3773 3774 def get_password_rules(self, account_id, **kwargs): 3775 """ 3776 Get the password rules 3777 This method retrieves the password rules for an account. 3778 This method makes a synchronous HTTP request by default. To make an 3779 asynchronous HTTP request, please define a `callback` function 3780 to be invoked when receiving the response. 3781 >>> def callback_function(response): 3782 >>> pprint(response) 3783 >>> 3784 >>> thread = api.get_password_rules(account_id, callback=callback_function) 3785 3786 :param callback function: The callback function 3787 for asynchronous request. (optional) 3788 :param str account_id: The external account number (int) or account ID Guid. (required) 3789 :return: AccountPasswordRules 3790 If the method is called asynchronously, 3791 returns the request thread. 3792 """ 3793 kwargs['_return_http_data_only'] = True 3794 if kwargs.get('callback'): 3795 return self.get_password_rules_with_http_info(account_id, **kwargs) 3796 else: 3797 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 3798 return data 3799 3800 def get_password_rules_with_http_info(self, account_id, **kwargs): 3801 """ 3802 Get the password rules 3803 This method retrieves the password rules for an account. 3804 This method makes a synchronous HTTP request by default. To make an 3805 asynchronous HTTP request, please define a `callback` function 3806 to be invoked when receiving the response. 3807 >>> def callback_function(response): 3808 >>> pprint(response) 3809 >>> 3810 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 3811 3812 :param callback function: The callback function 3813 for asynchronous request. (optional) 3814 :param str account_id: The external account number (int) or account ID Guid. (required) 3815 :return: AccountPasswordRules 3816 If the method is called asynchronously, 3817 returns the request thread. 3818 """ 3819 3820 all_params = ['account_id'] 3821 all_params.append('callback') 3822 all_params.append('_return_http_data_only') 3823 all_params.append('_preload_content') 3824 all_params.append('_request_timeout') 3825 3826 params = locals() 3827 for key, val in iteritems(params['kwargs']): 3828 if key not in all_params: 3829 raise TypeError( 3830 "Got an unexpected keyword argument '%s'" 3831 " to method get_password_rules" % key 3832 ) 3833 params[key] = val 3834 del params['kwargs'] 3835 # verify the required parameter 'account_id' is set 3836 if ('account_id' not in params) or (params['account_id'] is None): 3837 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 3838 3839 3840 collection_formats = {} 3841 3842 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 3843 path_params = {} 3844 if 'account_id' in params: 3845 path_params['accountId'] = params['account_id'] 3846 3847 query_params = {} 3848 3849 header_params = {} 3850 3851 form_params = [] 3852 local_var_files = {} 3853 3854 body_params = None 3855 # HTTP header `Accept` 3856 header_params['Accept'] = self.api_client.\ 3857 select_header_accept(['application/json']) 3858 3859 # Authentication setting 3860 auth_settings = [] 3861 3862 return self.api_client.call_api(resource_path, 'GET', 3863 path_params, 3864 query_params, 3865 header_params, 3866 body=body_params, 3867 post_params=form_params, 3868 files=local_var_files, 3869 response_type='AccountPasswordRules', 3870 auth_settings=auth_settings, 3871 callback=params.get('callback'), 3872 _return_http_data_only=params.get('_return_http_data_only'), 3873 _preload_content=params.get('_preload_content', True), 3874 _request_timeout=params.get('_request_timeout'), 3875 collection_formats=collection_formats) 3876 3877 def get_password_rules_0(self, **kwargs): 3878 """ 3879 Get membership account password rules 3880 3881 This method makes a synchronous HTTP request by default. To make an 3882 asynchronous HTTP request, please define a `callback` function 3883 to be invoked when receiving the response. 3884 >>> def callback_function(response): 3885 >>> pprint(response) 3886 >>> 3887 >>> thread = api.get_password_rules_0(callback=callback_function) 3888 3889 :param callback function: The callback function 3890 for asynchronous request. (optional) 3891 :return: UserPasswordRules 3892 If the method is called asynchronously, 3893 returns the request thread. 3894 """ 3895 kwargs['_return_http_data_only'] = True 3896 if kwargs.get('callback'): 3897 return self.get_password_rules_0_with_http_info(**kwargs) 3898 else: 3899 (data) = self.get_password_rules_0_with_http_info(**kwargs) 3900 return data 3901 3902 def get_password_rules_0_with_http_info(self, **kwargs): 3903 """ 3904 Get membership account password rules 3905 3906 This method makes a synchronous HTTP request by default. To make an 3907 asynchronous HTTP request, please define a `callback` function 3908 to be invoked when receiving the response. 3909 >>> def callback_function(response): 3910 >>> pprint(response) 3911 >>> 3912 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 3913 3914 :param callback function: The callback function 3915 for asynchronous request. (optional) 3916 :return: UserPasswordRules 3917 If the method is called asynchronously, 3918 returns the request thread. 3919 """ 3920 3921 all_params = [] 3922 all_params.append('callback') 3923 all_params.append('_return_http_data_only') 3924 all_params.append('_preload_content') 3925 all_params.append('_request_timeout') 3926 3927 params = locals() 3928 for key, val in iteritems(params['kwargs']): 3929 if key not in all_params: 3930 raise TypeError( 3931 "Got an unexpected keyword argument '%s'" 3932 " to method get_password_rules_0" % key 3933 ) 3934 params[key] = val 3935 del params['kwargs'] 3936 3937 collection_formats = {} 3938 3939 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 3940 path_params = {} 3941 3942 query_params = {} 3943 3944 header_params = {} 3945 3946 form_params = [] 3947 local_var_files = {} 3948 3949 body_params = None 3950 # HTTP header `Accept` 3951 header_params['Accept'] = self.api_client.\ 3952 select_header_accept(['application/json']) 3953 3954 # Authentication setting 3955 auth_settings = [] 3956 3957 return self.api_client.call_api(resource_path, 'GET', 3958 path_params, 3959 query_params, 3960 header_params, 3961 body=body_params, 3962 post_params=form_params, 3963 files=local_var_files, 3964 response_type='UserPasswordRules', 3965 auth_settings=auth_settings, 3966 callback=params.get('callback'), 3967 _return_http_data_only=params.get('_return_http_data_only'), 3968 _preload_content=params.get('_preload_content', True), 3969 _request_timeout=params.get('_request_timeout'), 3970 collection_formats=collection_formats) 3971 3972 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 3973 """ 3974 Returns a permissions profile in the specified account. 3975 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 3976 This method makes a synchronous HTTP request by default. To make an 3977 asynchronous HTTP request, please define a `callback` function 3978 to be invoked when receiving the response. 3979 >>> def callback_function(response): 3980 >>> pprint(response) 3981 >>> 3982 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 3983 3984 :param callback function: The callback function 3985 for asynchronous request. (optional) 3986 :param str account_id: The external account number (int) or account ID Guid. (required) 3987 :param str permission_profile_id: (required) 3988 :param str include: 3989 :return: PermissionProfile 3990 If the method is called asynchronously, 3991 returns the request thread. 3992 """ 3993 kwargs['_return_http_data_only'] = True 3994 if kwargs.get('callback'): 3995 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 3996 else: 3997 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 3998 return data 3999 4000 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4001 """ 4002 Returns a permissions profile in the specified account. 4003 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4004 This method makes a synchronous HTTP request by default. To make an 4005 asynchronous HTTP request, please define a `callback` function 4006 to be invoked when receiving the response. 4007 >>> def callback_function(response): 4008 >>> pprint(response) 4009 >>> 4010 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4011 4012 :param callback function: The callback function 4013 for asynchronous request. (optional) 4014 :param str account_id: The external account number (int) or account ID Guid. (required) 4015 :param str permission_profile_id: (required) 4016 :param str include: 4017 :return: PermissionProfile 4018 If the method is called asynchronously, 4019 returns the request thread. 4020 """ 4021 4022 all_params = ['account_id', 'permission_profile_id', 'include'] 4023 all_params.append('callback') 4024 all_params.append('_return_http_data_only') 4025 all_params.append('_preload_content') 4026 all_params.append('_request_timeout') 4027 4028 params = locals() 4029 for key, val in iteritems(params['kwargs']): 4030 if key not in all_params: 4031 raise TypeError( 4032 "Got an unexpected keyword argument '%s'" 4033 " to method get_permission_profile" % key 4034 ) 4035 params[key] = val 4036 del params['kwargs'] 4037 # verify the required parameter 'account_id' is set 4038 if ('account_id' not in params) or (params['account_id'] is None): 4039 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4040 # verify the required parameter 'permission_profile_id' is set 4041 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4042 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4043 4044 4045 collection_formats = {} 4046 4047 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4048 path_params = {} 4049 if 'account_id' in params: 4050 path_params['accountId'] = params['account_id'] 4051 if 'permission_profile_id' in params: 4052 path_params['permissionProfileId'] = params['permission_profile_id'] 4053 4054 query_params = {} 4055 if 'include' in params: 4056 query_params['include'] = params['include'] 4057 4058 header_params = {} 4059 4060 form_params = [] 4061 local_var_files = {} 4062 4063 body_params = None 4064 # HTTP header `Accept` 4065 header_params['Accept'] = self.api_client.\ 4066 select_header_accept(['application/json']) 4067 4068 # Authentication setting 4069 auth_settings = [] 4070 4071 return self.api_client.call_api(resource_path, 'GET', 4072 path_params, 4073 query_params, 4074 header_params, 4075 body=body_params, 4076 post_params=form_params, 4077 files=local_var_files, 4078 response_type='PermissionProfile', 4079 auth_settings=auth_settings, 4080 callback=params.get('callback'), 4081 _return_http_data_only=params.get('_return_http_data_only'), 4082 _preload_content=params.get('_preload_content', True), 4083 _request_timeout=params.get('_request_timeout'), 4084 collection_formats=collection_formats) 4085 4086 def get_provisioning(self, **kwargs): 4087 """ 4088 Retrieves the account provisioning information for the account. 4089 Retrieves the account provisioning information for the account. 4090 This method makes a synchronous HTTP request by default. To make an 4091 asynchronous HTTP request, please define a `callback` function 4092 to be invoked when receiving the response. 4093 >>> def callback_function(response): 4094 >>> pprint(response) 4095 >>> 4096 >>> thread = api.get_provisioning(callback=callback_function) 4097 4098 :param callback function: The callback function 4099 for asynchronous request. (optional) 4100 :return: ProvisioningInformation 4101 If the method is called asynchronously, 4102 returns the request thread. 4103 """ 4104 kwargs['_return_http_data_only'] = True 4105 if kwargs.get('callback'): 4106 return self.get_provisioning_with_http_info(**kwargs) 4107 else: 4108 (data) = self.get_provisioning_with_http_info(**kwargs) 4109 return data 4110 4111 def get_provisioning_with_http_info(self, **kwargs): 4112 """ 4113 Retrieves the account provisioning information for the account. 4114 Retrieves the account provisioning information for the account. 4115 This method makes a synchronous HTTP request by default. To make an 4116 asynchronous HTTP request, please define a `callback` function 4117 to be invoked when receiving the response. 4118 >>> def callback_function(response): 4119 >>> pprint(response) 4120 >>> 4121 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4122 4123 :param callback function: The callback function 4124 for asynchronous request. (optional) 4125 :return: ProvisioningInformation 4126 If the method is called asynchronously, 4127 returns the request thread. 4128 """ 4129 4130 all_params = [] 4131 all_params.append('callback') 4132 all_params.append('_return_http_data_only') 4133 all_params.append('_preload_content') 4134 all_params.append('_request_timeout') 4135 4136 params = locals() 4137 for key, val in iteritems(params['kwargs']): 4138 if key not in all_params: 4139 raise TypeError( 4140 "Got an unexpected keyword argument '%s'" 4141 " to method get_provisioning" % key 4142 ) 4143 params[key] = val 4144 del params['kwargs'] 4145 4146 collection_formats = {} 4147 4148 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4149 path_params = {} 4150 4151 query_params = {} 4152 4153 header_params = {} 4154 4155 form_params = [] 4156 local_var_files = {} 4157 4158 body_params = None 4159 # HTTP header `Accept` 4160 header_params['Accept'] = self.api_client.\ 4161 select_header_accept(['application/json']) 4162 4163 # Authentication setting 4164 auth_settings = [] 4165 4166 return self.api_client.call_api(resource_path, 'GET', 4167 path_params, 4168 query_params, 4169 header_params, 4170 body=body_params, 4171 post_params=form_params, 4172 files=local_var_files, 4173 response_type='ProvisioningInformation', 4174 auth_settings=auth_settings, 4175 callback=params.get('callback'), 4176 _return_http_data_only=params.get('_return_http_data_only'), 4177 _preload_content=params.get('_preload_content', True), 4178 _request_timeout=params.get('_request_timeout'), 4179 collection_formats=collection_formats) 4180 4181 def get_supported_languages(self, account_id, **kwargs): 4182 """ 4183 Gets list of supported languages for recipient language setting. 4184 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4185 This method makes a synchronous HTTP request by default. To make an 4186 asynchronous HTTP request, please define a `callback` function 4187 to be invoked when receiving the response. 4188 >>> def callback_function(response): 4189 >>> pprint(response) 4190 >>> 4191 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4192 4193 :param callback function: The callback function 4194 for asynchronous request. (optional) 4195 :param str account_id: The external account number (int) or account ID Guid. (required) 4196 :return: SupportedLanguages 4197 If the method is called asynchronously, 4198 returns the request thread. 4199 """ 4200 kwargs['_return_http_data_only'] = True 4201 if kwargs.get('callback'): 4202 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4203 else: 4204 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4205 return data 4206 4207 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4208 """ 4209 Gets list of supported languages for recipient language setting. 4210 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4211 This method makes a synchronous HTTP request by default. To make an 4212 asynchronous HTTP request, please define a `callback` function 4213 to be invoked when receiving the response. 4214 >>> def callback_function(response): 4215 >>> pprint(response) 4216 >>> 4217 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4218 4219 :param callback function: The callback function 4220 for asynchronous request. (optional) 4221 :param str account_id: The external account number (int) or account ID Guid. (required) 4222 :return: SupportedLanguages 4223 If the method is called asynchronously, 4224 returns the request thread. 4225 """ 4226 4227 all_params = ['account_id'] 4228 all_params.append('callback') 4229 all_params.append('_return_http_data_only') 4230 all_params.append('_preload_content') 4231 all_params.append('_request_timeout') 4232 4233 params = locals() 4234 for key, val in iteritems(params['kwargs']): 4235 if key not in all_params: 4236 raise TypeError( 4237 "Got an unexpected keyword argument '%s'" 4238 " to method get_supported_languages" % key 4239 ) 4240 params[key] = val 4241 del params['kwargs'] 4242 # verify the required parameter 'account_id' is set 4243 if ('account_id' not in params) or (params['account_id'] is None): 4244 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4245 4246 4247 collection_formats = {} 4248 4249 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4250 path_params = {} 4251 if 'account_id' in params: 4252 path_params['accountId'] = params['account_id'] 4253 4254 query_params = {} 4255 4256 header_params = {} 4257 4258 form_params = [] 4259 local_var_files = {} 4260 4261 body_params = None 4262 # HTTP header `Accept` 4263 header_params['Accept'] = self.api_client.\ 4264 select_header_accept(['application/json']) 4265 4266 # Authentication setting 4267 auth_settings = [] 4268 4269 return self.api_client.call_api(resource_path, 'GET', 4270 path_params, 4271 query_params, 4272 header_params, 4273 body=body_params, 4274 post_params=form_params, 4275 files=local_var_files, 4276 response_type='SupportedLanguages', 4277 auth_settings=auth_settings, 4278 callback=params.get('callback'), 4279 _return_http_data_only=params.get('_return_http_data_only'), 4280 _preload_content=params.get('_preload_content', True), 4281 _request_timeout=params.get('_request_timeout'), 4282 collection_formats=collection_formats) 4283 4284 def get_watermark(self, account_id, **kwargs): 4285 """ 4286 Get watermark information. 4287 4288 This method makes a synchronous HTTP request by default. To make an 4289 asynchronous HTTP request, please define a `callback` function 4290 to be invoked when receiving the response. 4291 >>> def callback_function(response): 4292 >>> pprint(response) 4293 >>> 4294 >>> thread = api.get_watermark(account_id, callback=callback_function) 4295 4296 :param callback function: The callback function 4297 for asynchronous request. (optional) 4298 :param str account_id: The external account number (int) or account ID Guid. (required) 4299 :return: Watermark 4300 If the method is called asynchronously, 4301 returns the request thread. 4302 """ 4303 kwargs['_return_http_data_only'] = True 4304 if kwargs.get('callback'): 4305 return self.get_watermark_with_http_info(account_id, **kwargs) 4306 else: 4307 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 4308 return data 4309 4310 def get_watermark_with_http_info(self, account_id, **kwargs): 4311 """ 4312 Get watermark information. 4313 4314 This method makes a synchronous HTTP request by default. To make an 4315 asynchronous HTTP request, please define a `callback` function 4316 to be invoked when receiving the response. 4317 >>> def callback_function(response): 4318 >>> pprint(response) 4319 >>> 4320 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 4321 4322 :param callback function: The callback function 4323 for asynchronous request. (optional) 4324 :param str account_id: The external account number (int) or account ID Guid. (required) 4325 :return: Watermark 4326 If the method is called asynchronously, 4327 returns the request thread. 4328 """ 4329 4330 all_params = ['account_id'] 4331 all_params.append('callback') 4332 all_params.append('_return_http_data_only') 4333 all_params.append('_preload_content') 4334 all_params.append('_request_timeout') 4335 4336 params = locals() 4337 for key, val in iteritems(params['kwargs']): 4338 if key not in all_params: 4339 raise TypeError( 4340 "Got an unexpected keyword argument '%s'" 4341 " to method get_watermark" % key 4342 ) 4343 params[key] = val 4344 del params['kwargs'] 4345 # verify the required parameter 'account_id' is set 4346 if ('account_id' not in params) or (params['account_id'] is None): 4347 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 4348 4349 4350 collection_formats = {} 4351 4352 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 4353 path_params = {} 4354 if 'account_id' in params: 4355 path_params['accountId'] = params['account_id'] 4356 4357 query_params = {} 4358 4359 header_params = {} 4360 4361 form_params = [] 4362 local_var_files = {} 4363 4364 body_params = None 4365 # HTTP header `Accept` 4366 header_params['Accept'] = self.api_client.\ 4367 select_header_accept(['application/json']) 4368 4369 # Authentication setting 4370 auth_settings = [] 4371 4372 return self.api_client.call_api(resource_path, 'GET', 4373 path_params, 4374 query_params, 4375 header_params, 4376 body=body_params, 4377 post_params=form_params, 4378 files=local_var_files, 4379 response_type='Watermark', 4380 auth_settings=auth_settings, 4381 callback=params.get('callback'), 4382 _return_http_data_only=params.get('_return_http_data_only'), 4383 _preload_content=params.get('_preload_content', True), 4384 _request_timeout=params.get('_request_timeout'), 4385 collection_formats=collection_formats) 4386 4387 def get_watermark_preview(self, account_id, **kwargs): 4388 """ 4389 Get watermark preview. 4390 4391 This method makes a synchronous HTTP request by default. To make an 4392 asynchronous HTTP request, please define a `callback` function 4393 to be invoked when receiving the response. 4394 >>> def callback_function(response): 4395 >>> pprint(response) 4396 >>> 4397 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 4398 4399 :param callback function: The callback function 4400 for asynchronous request. (optional) 4401 :param str account_id: The external account number (int) or account ID Guid. (required) 4402 :param Watermark watermark: 4403 :return: Watermark 4404 If the method is called asynchronously, 4405 returns the request thread. 4406 """ 4407 kwargs['_return_http_data_only'] = True 4408 if kwargs.get('callback'): 4409 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 4410 else: 4411 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 4412 return data 4413 4414 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 4415 """ 4416 Get watermark preview. 4417 4418 This method makes a synchronous HTTP request by default. To make an 4419 asynchronous HTTP request, please define a `callback` function 4420 to be invoked when receiving the response. 4421 >>> def callback_function(response): 4422 >>> pprint(response) 4423 >>> 4424 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 4425 4426 :param callback function: The callback function 4427 for asynchronous request. (optional) 4428 :param str account_id: The external account number (int) or account ID Guid. (required) 4429 :param Watermark watermark: 4430 :return: Watermark 4431 If the method is called asynchronously, 4432 returns the request thread. 4433 """ 4434 4435 all_params = ['account_id', 'watermark'] 4436 all_params.append('callback') 4437 all_params.append('_return_http_data_only') 4438 all_params.append('_preload_content') 4439 all_params.append('_request_timeout') 4440 4441 params = locals() 4442 for key, val in iteritems(params['kwargs']): 4443 if key not in all_params: 4444 raise TypeError( 4445 "Got an unexpected keyword argument '%s'" 4446 " to method get_watermark_preview" % key 4447 ) 4448 params[key] = val 4449 del params['kwargs'] 4450 # verify the required parameter 'account_id' is set 4451 if ('account_id' not in params) or (params['account_id'] is None): 4452 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 4453 4454 4455 collection_formats = {} 4456 4457 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 4458 path_params = {} 4459 if 'account_id' in params: 4460 path_params['accountId'] = params['account_id'] 4461 4462 query_params = {} 4463 4464 header_params = {} 4465 4466 form_params = [] 4467 local_var_files = {} 4468 4469 body_params = None 4470 if 'watermark' in params: 4471 body_params = params['watermark'] 4472 # HTTP header `Accept` 4473 header_params['Accept'] = self.api_client.\ 4474 select_header_accept(['application/json']) 4475 4476 # Authentication setting 4477 auth_settings = [] 4478 4479 return self.api_client.call_api(resource_path, 'PUT', 4480 path_params, 4481 query_params, 4482 header_params, 4483 body=body_params, 4484 post_params=form_params, 4485 files=local_var_files, 4486 response_type='Watermark', 4487 auth_settings=auth_settings, 4488 callback=params.get('callback'), 4489 _return_http_data_only=params.get('_return_http_data_only'), 4490 _preload_content=params.get('_preload_content', True), 4491 _request_timeout=params.get('_request_timeout'), 4492 collection_formats=collection_formats) 4493 4494 def list_brands(self, account_id, **kwargs): 4495 """ 4496 Gets a list of brand profiles. 4497 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 4498 This method makes a synchronous HTTP request by default. To make an 4499 asynchronous HTTP request, please define a `callback` function 4500 to be invoked when receiving the response. 4501 >>> def callback_function(response): 4502 >>> pprint(response) 4503 >>> 4504 >>> thread = api.list_brands(account_id, callback=callback_function) 4505 4506 :param callback function: The callback function 4507 for asynchronous request. (optional) 4508 :param str account_id: The external account number (int) or account ID Guid. (required) 4509 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 4510 :param str include_logos: When set to **true**, returns the logos associated with the brand. 4511 :return: BrandsResponse 4512 If the method is called asynchronously, 4513 returns the request thread. 4514 """ 4515 kwargs['_return_http_data_only'] = True 4516 if kwargs.get('callback'): 4517 return self.list_brands_with_http_info(account_id, **kwargs) 4518 else: 4519 (data) = self.list_brands_with_http_info(account_id, **kwargs) 4520 return data 4521 4522 def list_brands_with_http_info(self, account_id, **kwargs): 4523 """ 4524 Gets a list of brand profiles. 4525 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 4526 This method makes a synchronous HTTP request by default. To make an 4527 asynchronous HTTP request, please define a `callback` function 4528 to be invoked when receiving the response. 4529 >>> def callback_function(response): 4530 >>> pprint(response) 4531 >>> 4532 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 4533 4534 :param callback function: The callback function 4535 for asynchronous request. (optional) 4536 :param str account_id: The external account number (int) or account ID Guid. (required) 4537 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 4538 :param str include_logos: When set to **true**, returns the logos associated with the brand. 4539 :return: BrandsResponse 4540 If the method is called asynchronously, 4541 returns the request thread. 4542 """ 4543 4544 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 4545 all_params.append('callback') 4546 all_params.append('_return_http_data_only') 4547 all_params.append('_preload_content') 4548 all_params.append('_request_timeout') 4549 4550 params = locals() 4551 for key, val in iteritems(params['kwargs']): 4552 if key not in all_params: 4553 raise TypeError( 4554 "Got an unexpected keyword argument '%s'" 4555 " to method list_brands" % key 4556 ) 4557 params[key] = val 4558 del params['kwargs'] 4559 # verify the required parameter 'account_id' is set 4560 if ('account_id' not in params) or (params['account_id'] is None): 4561 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 4562 4563 4564 collection_formats = {} 4565 4566 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 4567 path_params = {} 4568 if 'account_id' in params: 4569 path_params['accountId'] = params['account_id'] 4570 4571 query_params = {} 4572 if 'exclude_distributor_brand' in params: 4573 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 4574 if 'include_logos' in params: 4575 query_params['include_logos'] = params['include_logos'] 4576 4577 header_params = {} 4578 4579 form_params = [] 4580 local_var_files = {} 4581 4582 body_params = None 4583 # HTTP header `Accept` 4584 header_params['Accept'] = self.api_client.\ 4585 select_header_accept(['application/json']) 4586 4587 # Authentication setting 4588 auth_settings = [] 4589 4590 return self.api_client.call_api(resource_path, 'GET', 4591 path_params, 4592 query_params, 4593 header_params, 4594 body=body_params, 4595 post_params=form_params, 4596 files=local_var_files, 4597 response_type='BrandsResponse', 4598 auth_settings=auth_settings, 4599 callback=params.get('callback'), 4600 _return_http_data_only=params.get('_return_http_data_only'), 4601 _preload_content=params.get('_preload_content', True), 4602 _request_timeout=params.get('_request_timeout'), 4603 collection_formats=collection_formats) 4604 4605 def list_custom_fields(self, account_id, **kwargs): 4606 """ 4607 Gets a list of custom fields associated with the account. 4608 Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. 4609 This method makes a synchronous HTTP request by default. To make an 4610 asynchronous HTTP request, please define a `callback` function 4611 to be invoked when receiving the response. 4612 >>> def callback_function(response): 4613 >>> pprint(response) 4614 >>> 4615 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 4616 4617 :param callback function: The callback function 4618 for asynchronous request. (optional) 4619 :param str account_id: The external account number (int) or account ID Guid. (required) 4620 :return: CustomFields 4621 If the method is called asynchronously, 4622 returns the request thread. 4623 """ 4624 kwargs['_return_http_data_only'] = True 4625 if kwargs.get('callback'): 4626 return self.list_custom_fields_with_http_info(account_id, **kwargs) 4627 else: 4628 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 4629 return data 4630 4631 def list_custom_fields_with_http_info(self, account_id, **kwargs): 4632 """ 4633 Gets a list of custom fields associated with the account. 4634 Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. 4635 This method makes a synchronous HTTP request by default. To make an 4636 asynchronous HTTP request, please define a `callback` function 4637 to be invoked when receiving the response. 4638 >>> def callback_function(response): 4639 >>> pprint(response) 4640 >>> 4641 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 4642 4643 :param callback function: The callback function 4644 for asynchronous request. (optional) 4645 :param str account_id: The external account number (int) or account ID Guid. (required) 4646 :return: CustomFields 4647 If the method is called asynchronously, 4648 returns the request thread. 4649 """ 4650 4651 all_params = ['account_id'] 4652 all_params.append('callback') 4653 all_params.append('_return_http_data_only') 4654 all_params.append('_preload_content') 4655 all_params.append('_request_timeout') 4656 4657 params = locals() 4658 for key, val in iteritems(params['kwargs']): 4659 if key not in all_params: 4660 raise TypeError( 4661 "Got an unexpected keyword argument '%s'" 4662 " to method list_custom_fields" % key 4663 ) 4664 params[key] = val 4665 del params['kwargs'] 4666 # verify the required parameter 'account_id' is set 4667 if ('account_id' not in params) or (params['account_id'] is None): 4668 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 4669 4670 4671 collection_formats = {} 4672 4673 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 4674 path_params = {} 4675 if 'account_id' in params: 4676 path_params['accountId'] = params['account_id'] 4677 4678 query_params = {} 4679 4680 header_params = {} 4681 4682 form_params = [] 4683 local_var_files = {} 4684 4685 body_params = None 4686 # HTTP header `Accept` 4687 header_params['Accept'] = self.api_client.\ 4688 select_header_accept(['application/json']) 4689 4690 # Authentication setting 4691 auth_settings = [] 4692 4693 return self.api_client.call_api(resource_path, 'GET', 4694 path_params, 4695 query_params, 4696 header_params, 4697 body=body_params, 4698 post_params=form_params, 4699 files=local_var_files, 4700 response_type='CustomFields', 4701 auth_settings=auth_settings, 4702 callback=params.get('callback'), 4703 _return_http_data_only=params.get('_return_http_data_only'), 4704 _preload_content=params.get('_preload_content', True), 4705 _request_timeout=params.get('_request_timeout'), 4706 collection_formats=collection_formats) 4707 4708 def list_permissions(self, account_id, **kwargs): 4709 """ 4710 Gets a list of permission profiles. 4711 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 4712 This method makes a synchronous HTTP request by default. To make an 4713 asynchronous HTTP request, please define a `callback` function 4714 to be invoked when receiving the response. 4715 >>> def callback_function(response): 4716 >>> pprint(response) 4717 >>> 4718 >>> thread = api.list_permissions(account_id, callback=callback_function) 4719 4720 :param callback function: The callback function 4721 for asynchronous request. (optional) 4722 :param str account_id: The external account number (int) or account ID Guid. (required) 4723 :param str include: 4724 :return: PermissionProfileInformation 4725 If the method is called asynchronously, 4726 returns the request thread. 4727 """ 4728 kwargs['_return_http_data_only'] = True 4729 if kwargs.get('callback'): 4730 return self.list_permissions_with_http_info(account_id, **kwargs) 4731 else: 4732 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 4733 return data 4734 4735 def list_permissions_with_http_info(self, account_id, **kwargs): 4736 """ 4737 Gets a list of permission profiles. 4738 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 4739 This method makes a synchronous HTTP request by default. To make an 4740 asynchronous HTTP request, please define a `callback` function 4741 to be invoked when receiving the response. 4742 >>> def callback_function(response): 4743 >>> pprint(response) 4744 >>> 4745 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 4746 4747 :param callback function: The callback function 4748 for asynchronous request. (optional) 4749 :param str account_id: The external account number (int) or account ID Guid. (required) 4750 :param str include: 4751 :return: PermissionProfileInformation 4752 If the method is called asynchronously, 4753 returns the request thread. 4754 """ 4755 4756 all_params = ['account_id', 'include'] 4757 all_params.append('callback') 4758 all_params.append('_return_http_data_only') 4759 all_params.append('_preload_content') 4760 all_params.append('_request_timeout') 4761 4762 params = locals() 4763 for key, val in iteritems(params['kwargs']): 4764 if key not in all_params: 4765 raise TypeError( 4766 "Got an unexpected keyword argument '%s'" 4767 " to method list_permissions" % key 4768 ) 4769 params[key] = val 4770 del params['kwargs'] 4771 # verify the required parameter 'account_id' is set 4772 if ('account_id' not in params) or (params['account_id'] is None): 4773 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 4774 4775 4776 collection_formats = {} 4777 4778 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 4779 path_params = {} 4780 if 'account_id' in params: 4781 path_params['accountId'] = params['account_id'] 4782 4783 query_params = {} 4784 if 'include' in params: 4785 query_params['include'] = params['include'] 4786 4787 header_params = {} 4788 4789 form_params = [] 4790 local_var_files = {} 4791 4792 body_params = None 4793 # HTTP header `Accept` 4794 header_params['Accept'] = self.api_client.\ 4795 select_header_accept(['application/json']) 4796 4797 # Authentication setting 4798 auth_settings = [] 4799 4800 return self.api_client.call_api(resource_path, 'GET', 4801 path_params, 4802 query_params, 4803 header_params, 4804 body=body_params, 4805 post_params=form_params, 4806 files=local_var_files, 4807 response_type='PermissionProfileInformation', 4808 auth_settings=auth_settings, 4809 callback=params.get('callback'), 4810 _return_http_data_only=params.get('_return_http_data_only'), 4811 _preload_content=params.get('_preload_content', True), 4812 _request_timeout=params.get('_request_timeout'), 4813 collection_formats=collection_formats) 4814 4815 def list_recipient_names_by_email(self, account_id, **kwargs): 4816 """ 4817 Gets recipient names associated with an email address. 4818 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 4819 This method makes a synchronous HTTP request by default. To make an 4820 asynchronous HTTP request, please define a `callback` function 4821 to be invoked when receiving the response. 4822 >>> def callback_function(response): 4823 >>> pprint(response) 4824 >>> 4825 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 4826 4827 :param callback function: The callback function 4828 for asynchronous request. (optional) 4829 :param str account_id: The external account number (int) or account ID Guid. (required) 4830 :param str email: The email address for the user 4831 :return: RecipientNamesResponse 4832 If the method is called asynchronously, 4833 returns the request thread. 4834 """ 4835 kwargs['_return_http_data_only'] = True 4836 if kwargs.get('callback'): 4837 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 4838 else: 4839 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 4840 return data 4841 4842 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 4843 """ 4844 Gets recipient names associated with an email address. 4845 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 4846 This method makes a synchronous HTTP request by default. To make an 4847 asynchronous HTTP request, please define a `callback` function 4848 to be invoked when receiving the response. 4849 >>> def callback_function(response): 4850 >>> pprint(response) 4851 >>> 4852 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 4853 4854 :param callback function: The callback function 4855 for asynchronous request. (optional) 4856 :param str account_id: The external account number (int) or account ID Guid. (required) 4857 :param str email: The email address for the user 4858 :return: RecipientNamesResponse 4859 If the method is called asynchronously, 4860 returns the request thread. 4861 """ 4862 4863 all_params = ['account_id', 'email'] 4864 all_params.append('callback') 4865 all_params.append('_return_http_data_only') 4866 all_params.append('_preload_content') 4867 all_params.append('_request_timeout') 4868 4869 params = locals() 4870 for key, val in iteritems(params['kwargs']): 4871 if key not in all_params: 4872 raise TypeError( 4873 "Got an unexpected keyword argument '%s'" 4874 " to method list_recipient_names_by_email" % key 4875 ) 4876 params[key] = val 4877 del params['kwargs'] 4878 # verify the required parameter 'account_id' is set 4879 if ('account_id' not in params) or (params['account_id'] is None): 4880 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 4881 4882 4883 collection_formats = {} 4884 4885 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 4886 path_params = {} 4887 if 'account_id' in params: 4888 path_params['accountId'] = params['account_id'] 4889 4890 query_params = {} 4891 if 'email' in params: 4892 query_params['email'] = params['email'] 4893 4894 header_params = {} 4895 4896 form_params = [] 4897 local_var_files = {} 4898 4899 body_params = None 4900 # HTTP header `Accept` 4901 header_params['Accept'] = self.api_client.\ 4902 select_header_accept(['application/json']) 4903 4904 # Authentication setting 4905 auth_settings = [] 4906 4907 return self.api_client.call_api(resource_path, 'GET', 4908 path_params, 4909 query_params, 4910 header_params, 4911 body=body_params, 4912 post_params=form_params, 4913 files=local_var_files, 4914 response_type='RecipientNamesResponse', 4915 auth_settings=auth_settings, 4916 callback=params.get('callback'), 4917 _return_http_data_only=params.get('_return_http_data_only'), 4918 _preload_content=params.get('_preload_content', True), 4919 _request_timeout=params.get('_request_timeout'), 4920 collection_formats=collection_formats) 4921 4922 def list_settings(self, account_id, **kwargs): 4923 """ 4924 Gets account settings information. 4925 Retrieves the account settings information for the specified account. 4926 This method makes a synchronous HTTP request by default. To make an 4927 asynchronous HTTP request, please define a `callback` function 4928 to be invoked when receiving the response. 4929 >>> def callback_function(response): 4930 >>> pprint(response) 4931 >>> 4932 >>> thread = api.list_settings(account_id, callback=callback_function) 4933 4934 :param callback function: The callback function 4935 for asynchronous request. (optional) 4936 :param str account_id: The external account number (int) or account ID Guid. (required) 4937 :return: AccountSettingsInformation 4938 If the method is called asynchronously, 4939 returns the request thread. 4940 """ 4941 kwargs['_return_http_data_only'] = True 4942 if kwargs.get('callback'): 4943 return self.list_settings_with_http_info(account_id, **kwargs) 4944 else: 4945 (data) = self.list_settings_with_http_info(account_id, **kwargs) 4946 return data 4947 4948 def list_settings_with_http_info(self, account_id, **kwargs): 4949 """ 4950 Gets account settings information. 4951 Retrieves the account settings information for the specified account. 4952 This method makes a synchronous HTTP request by default. To make an 4953 asynchronous HTTP request, please define a `callback` function 4954 to be invoked when receiving the response. 4955 >>> def callback_function(response): 4956 >>> pprint(response) 4957 >>> 4958 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 4959 4960 :param callback function: The callback function 4961 for asynchronous request. (optional) 4962 :param str account_id: The external account number (int) or account ID Guid. (required) 4963 :return: AccountSettingsInformation 4964 If the method is called asynchronously, 4965 returns the request thread. 4966 """ 4967 4968 all_params = ['account_id'] 4969 all_params.append('callback') 4970 all_params.append('_return_http_data_only') 4971 all_params.append('_preload_content') 4972 all_params.append('_request_timeout') 4973 4974 params = locals() 4975 for key, val in iteritems(params['kwargs']): 4976 if key not in all_params: 4977 raise TypeError( 4978 "Got an unexpected keyword argument '%s'" 4979 " to method list_settings" % key 4980 ) 4981 params[key] = val 4982 del params['kwargs'] 4983 # verify the required parameter 'account_id' is set 4984 if ('account_id' not in params) or (params['account_id'] is None): 4985 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 4986 4987 4988 collection_formats = {} 4989 4990 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 4991 path_params = {} 4992 if 'account_id' in params: 4993 path_params['accountId'] = params['account_id'] 4994 4995 query_params = {} 4996 4997 header_params = {} 4998 4999 form_params = [] 5000 local_var_files = {} 5001 5002 body_params = None 5003 # HTTP header `Accept` 5004 header_params['Accept'] = self.api_client.\ 5005 select_header_accept(['application/json']) 5006 5007 # Authentication setting 5008 auth_settings = [] 5009 5010 return self.api_client.call_api(resource_path, 'GET', 5011 path_params, 5012 query_params, 5013 header_params, 5014 body=body_params, 5015 post_params=form_params, 5016 files=local_var_files, 5017 response_type='AccountSettingsInformation', 5018 auth_settings=auth_settings, 5019 callback=params.get('callback'), 5020 _return_http_data_only=params.get('_return_http_data_only'), 5021 _preload_content=params.get('_preload_content', True), 5022 _request_timeout=params.get('_request_timeout'), 5023 collection_formats=collection_formats) 5024 5025 def list_shared_access(self, account_id, **kwargs): 5026 """ 5027 Reserved: Gets the shared item status for one or more users. 5028 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5029 This method makes a synchronous HTTP request by default. To make an 5030 asynchronous HTTP request, please define a `callback` function 5031 to be invoked when receiving the response. 5032 >>> def callback_function(response): 5033 >>> pprint(response) 5034 >>> 5035 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5036 5037 :param callback function: The callback function 5038 for asynchronous request. (optional) 5039 :param str account_id: The external account number (int) or account ID Guid. (required) 5040 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5041 :param str envelopes_not_shared_user_status: 5042 :param str folder_ids: 5043 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5044 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5045 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5046 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5047 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5048 :return: AccountSharedAccess 5049 If the method is called asynchronously, 5050 returns the request thread. 5051 """ 5052 kwargs['_return_http_data_only'] = True 5053 if kwargs.get('callback'): 5054 return self.list_shared_access_with_http_info(account_id, **kwargs) 5055 else: 5056 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5057 return data 5058 5059 def list_shared_access_with_http_info(self, account_id, **kwargs): 5060 """ 5061 Reserved: Gets the shared item status for one or more users. 5062 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5063 This method makes a synchronous HTTP request by default. To make an 5064 asynchronous HTTP request, please define a `callback` function 5065 to be invoked when receiving the response. 5066 >>> def callback_function(response): 5067 >>> pprint(response) 5068 >>> 5069 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5070 5071 :param callback function: The callback function 5072 for asynchronous request. (optional) 5073 :param str account_id: The external account number (int) or account ID Guid. (required) 5074 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5075 :param str envelopes_not_shared_user_status: 5076 :param str folder_ids: 5077 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5078 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5079 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5080 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5081 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5082 :return: AccountSharedAccess 5083 If the method is called asynchronously, 5084 returns the request thread. 5085 """ 5086 5087 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5088 all_params.append('callback') 5089 all_params.append('_return_http_data_only') 5090 all_params.append('_preload_content') 5091 all_params.append('_request_timeout') 5092 5093 params = locals() 5094 for key, val in iteritems(params['kwargs']): 5095 if key not in all_params: 5096 raise TypeError( 5097 "Got an unexpected keyword argument '%s'" 5098 " to method list_shared_access" % key 5099 ) 5100 params[key] = val 5101 del params['kwargs'] 5102 # verify the required parameter 'account_id' is set 5103 if ('account_id' not in params) or (params['account_id'] is None): 5104 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5105 5106 5107 collection_formats = {} 5108 5109 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5110 path_params = {} 5111 if 'account_id' in params: 5112 path_params['accountId'] = params['account_id'] 5113 5114 query_params = {} 5115 if 'count' in params: 5116 query_params['count'] = params['count'] 5117 if 'envelopes_not_shared_user_status' in params: 5118 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5119 if 'folder_ids' in params: 5120 query_params['folder_ids'] = params['folder_ids'] 5121 if 'item_type' in params: 5122 query_params['item_type'] = params['item_type'] 5123 if 'search_text' in params: 5124 query_params['search_text'] = params['search_text'] 5125 if 'shared' in params: 5126 query_params['shared'] = params['shared'] 5127 if 'start_position' in params: 5128 query_params['start_position'] = params['start_position'] 5129 if 'user_ids' in params: 5130 query_params['user_ids'] = params['user_ids'] 5131 5132 header_params = {} 5133 5134 form_params = [] 5135 local_var_files = {} 5136 5137 body_params = None 5138 # HTTP header `Accept` 5139 header_params['Accept'] = self.api_client.\ 5140 select_header_accept(['application/json']) 5141 5142 # Authentication setting 5143 auth_settings = [] 5144 5145 return self.api_client.call_api(resource_path, 'GET', 5146 path_params, 5147 query_params, 5148 header_params, 5149 body=body_params, 5150 post_params=form_params, 5151 files=local_var_files, 5152 response_type='AccountSharedAccess', 5153 auth_settings=auth_settings, 5154 callback=params.get('callback'), 5155 _return_http_data_only=params.get('_return_http_data_only'), 5156 _preload_content=params.get('_preload_content', True), 5157 _request_timeout=params.get('_request_timeout'), 5158 collection_formats=collection_formats) 5159 5160 def list_signature_providers(self, account_id, **kwargs): 5161 """ 5162 Returns Account available signature providers for specified account. 5163 Returns a list of signature providers that the specified account can use. 5164 This method makes a synchronous HTTP request by default. To make an 5165 asynchronous HTTP request, please define a `callback` function 5166 to be invoked when receiving the response. 5167 >>> def callback_function(response): 5168 >>> pprint(response) 5169 >>> 5170 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 5171 5172 :param callback function: The callback function 5173 for asynchronous request. (optional) 5174 :param str account_id: The external account number (int) or account ID Guid. (required) 5175 :return: AccountSignatureProviders 5176 If the method is called asynchronously, 5177 returns the request thread. 5178 """ 5179 kwargs['_return_http_data_only'] = True 5180 if kwargs.get('callback'): 5181 return self.list_signature_providers_with_http_info(account_id, **kwargs) 5182 else: 5183 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 5184 return data 5185 5186 def list_signature_providers_with_http_info(self, account_id, **kwargs): 5187 """ 5188 Returns Account available signature providers for specified account. 5189 Returns a list of signature providers that the specified account can use. 5190 This method makes a synchronous HTTP request by default. To make an 5191 asynchronous HTTP request, please define a `callback` function 5192 to be invoked when receiving the response. 5193 >>> def callback_function(response): 5194 >>> pprint(response) 5195 >>> 5196 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 5197 5198 :param callback function: The callback function 5199 for asynchronous request. (optional) 5200 :param str account_id: The external account number (int) or account ID Guid. (required) 5201 :return: AccountSignatureProviders 5202 If the method is called asynchronously, 5203 returns the request thread. 5204 """ 5205 5206 all_params = ['account_id'] 5207 all_params.append('callback') 5208 all_params.append('_return_http_data_only') 5209 all_params.append('_preload_content') 5210 all_params.append('_request_timeout') 5211 5212 params = locals() 5213 for key, val in iteritems(params['kwargs']): 5214 if key not in all_params: 5215 raise TypeError( 5216 "Got an unexpected keyword argument '%s'" 5217 " to method list_signature_providers" % key 5218 ) 5219 params[key] = val 5220 del params['kwargs'] 5221 # verify the required parameter 'account_id' is set 5222 if ('account_id' not in params) or (params['account_id'] is None): 5223 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 5224 5225 5226 collection_formats = {} 5227 5228 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 5229 path_params = {} 5230 if 'account_id' in params: 5231 path_params['accountId'] = params['account_id'] 5232 5233 query_params = {} 5234 5235 header_params = {} 5236 5237 form_params = [] 5238 local_var_files = {} 5239 5240 body_params = None 5241 # HTTP header `Accept` 5242 header_params['Accept'] = self.api_client.\ 5243 select_header_accept(['application/json']) 5244 5245 # Authentication setting 5246 auth_settings = [] 5247 5248 return self.api_client.call_api(resource_path, 'GET', 5249 path_params, 5250 query_params, 5251 header_params, 5252 body=body_params, 5253 post_params=form_params, 5254 files=local_var_files, 5255 response_type='AccountSignatureProviders', 5256 auth_settings=auth_settings, 5257 callback=params.get('callback'), 5258 _return_http_data_only=params.get('_return_http_data_only'), 5259 _preload_content=params.get('_preload_content', True), 5260 _request_timeout=params.get('_request_timeout'), 5261 collection_formats=collection_formats) 5262 5263 def list_unsupported_file_types(self, account_id, **kwargs): 5264 """ 5265 Gets a list of unsupported file types. 5266 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 5267 This method makes a synchronous HTTP request by default. To make an 5268 asynchronous HTTP request, please define a `callback` function 5269 to be invoked when receiving the response. 5270 >>> def callback_function(response): 5271 >>> pprint(response) 5272 >>> 5273 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 5274 5275 :param callback function: The callback function 5276 for asynchronous request. (optional) 5277 :param str account_id: The external account number (int) or account ID Guid. (required) 5278 :return: FileTypeList 5279 If the method is called asynchronously, 5280 returns the request thread. 5281 """ 5282 kwargs['_return_http_data_only'] = True 5283 if kwargs.get('callback'): 5284 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 5285 else: 5286 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 5287 return data 5288 5289 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 5290 """ 5291 Gets a list of unsupported file types. 5292 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 5293 This method makes a synchronous HTTP request by default. To make an 5294 asynchronous HTTP request, please define a `callback` function 5295 to be invoked when receiving the response. 5296 >>> def callback_function(response): 5297 >>> pprint(response) 5298 >>> 5299 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 5300 5301 :param callback function: The callback function 5302 for asynchronous request. (optional) 5303 :param str account_id: The external account number (int) or account ID Guid. (required) 5304 :return: FileTypeList 5305 If the method is called asynchronously, 5306 returns the request thread. 5307 """ 5308 5309 all_params = ['account_id'] 5310 all_params.append('callback') 5311 all_params.append('_return_http_data_only') 5312 all_params.append('_preload_content') 5313 all_params.append('_request_timeout') 5314 5315 params = locals() 5316 for key, val in iteritems(params['kwargs']): 5317 if key not in all_params: 5318 raise TypeError( 5319 "Got an unexpected keyword argument '%s'" 5320 " to method list_unsupported_file_types" % key 5321 ) 5322 params[key] = val 5323 del params['kwargs'] 5324 # verify the required parameter 'account_id' is set 5325 if ('account_id' not in params) or (params['account_id'] is None): 5326 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 5327 5328 5329 collection_formats = {} 5330 5331 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 5332 path_params = {} 5333 if 'account_id' in params: 5334 path_params['accountId'] = params['account_id'] 5335 5336 query_params = {} 5337 5338 header_params = {} 5339 5340 form_params = [] 5341 local_var_files = {} 5342 5343 body_params = None 5344 # HTTP header `Accept` 5345 header_params['Accept'] = self.api_client.\ 5346 select_header_accept(['application/json']) 5347 5348 # Authentication setting 5349 auth_settings = [] 5350 5351 return self.api_client.call_api(resource_path, 'GET', 5352 path_params, 5353 query_params, 5354 header_params, 5355 body=body_params, 5356 post_params=form_params, 5357 files=local_var_files, 5358 response_type='FileTypeList', 5359 auth_settings=auth_settings, 5360 callback=params.get('callback'), 5361 _return_http_data_only=params.get('_return_http_data_only'), 5362 _preload_content=params.get('_preload_content', True), 5363 _request_timeout=params.get('_request_timeout'), 5364 collection_formats=collection_formats) 5365 5366 def un_favorite_template(self, account_id, **kwargs): 5367 """ 5368 Unfavorite a template 5369 5370 This method makes a synchronous HTTP request by default. To make an 5371 asynchronous HTTP request, please define a `callback` function 5372 to be invoked when receiving the response. 5373 >>> def callback_function(response): 5374 >>> pprint(response) 5375 >>> 5376 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 5377 5378 :param callback function: The callback function 5379 for asynchronous request. (optional) 5380 :param str account_id: The external account number (int) or account ID Guid. (required) 5381 :param FavoriteTemplatesInfo favorite_templates_info: 5382 :return: FavoriteTemplatesInfo 5383 If the method is called asynchronously, 5384 returns the request thread. 5385 """ 5386 kwargs['_return_http_data_only'] = True 5387 if kwargs.get('callback'): 5388 return self.un_favorite_template_with_http_info(account_id, **kwargs) 5389 else: 5390 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 5391 return data 5392 5393 def un_favorite_template_with_http_info(self, account_id, **kwargs): 5394 """ 5395 Unfavorite a template 5396 5397 This method makes a synchronous HTTP request by default. To make an 5398 asynchronous HTTP request, please define a `callback` function 5399 to be invoked when receiving the response. 5400 >>> def callback_function(response): 5401 >>> pprint(response) 5402 >>> 5403 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 5404 5405 :param callback function: The callback function 5406 for asynchronous request. (optional) 5407 :param str account_id: The external account number (int) or account ID Guid. (required) 5408 :param FavoriteTemplatesInfo favorite_templates_info: 5409 :return: FavoriteTemplatesInfo 5410 If the method is called asynchronously, 5411 returns the request thread. 5412 """ 5413 5414 all_params = ['account_id', 'favorite_templates_info'] 5415 all_params.append('callback') 5416 all_params.append('_return_http_data_only') 5417 all_params.append('_preload_content') 5418 all_params.append('_request_timeout') 5419 5420 params = locals() 5421 for key, val in iteritems(params['kwargs']): 5422 if key not in all_params: 5423 raise TypeError( 5424 "Got an unexpected keyword argument '%s'" 5425 " to method un_favorite_template" % key 5426 ) 5427 params[key] = val 5428 del params['kwargs'] 5429 # verify the required parameter 'account_id' is set 5430 if ('account_id' not in params) or (params['account_id'] is None): 5431 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 5432 5433 5434 collection_formats = {} 5435 5436 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 5437 path_params = {} 5438 if 'account_id' in params: 5439 path_params['accountId'] = params['account_id'] 5440 5441 query_params = {} 5442 5443 header_params = {} 5444 5445 form_params = [] 5446 local_var_files = {} 5447 5448 body_params = None 5449 if 'favorite_templates_info' in params: 5450 body_params = params['favorite_templates_info'] 5451 # HTTP header `Accept` 5452 header_params['Accept'] = self.api_client.\ 5453 select_header_accept(['application/json']) 5454 5455 # Authentication setting 5456 auth_settings = [] 5457 5458 return self.api_client.call_api(resource_path, 'DELETE', 5459 path_params, 5460 query_params, 5461 header_params, 5462 body=body_params, 5463 post_params=form_params, 5464 files=local_var_files, 5465 response_type='FavoriteTemplatesInfo', 5466 auth_settings=auth_settings, 5467 callback=params.get('callback'), 5468 _return_http_data_only=params.get('_return_http_data_only'), 5469 _preload_content=params.get('_preload_content', True), 5470 _request_timeout=params.get('_request_timeout'), 5471 collection_formats=collection_formats) 5472 5473 def update_account_signature(self, account_id, **kwargs): 5474 """ 5475 Updates a account signature. 5476 5477 This method makes a synchronous HTTP request by default. To make an 5478 asynchronous HTTP request, please define a `callback` function 5479 to be invoked when receiving the response. 5480 >>> def callback_function(response): 5481 >>> pprint(response) 5482 >>> 5483 >>> thread = api.update_account_signature(account_id, callback=callback_function) 5484 5485 :param callback function: The callback function 5486 for asynchronous request. (optional) 5487 :param str account_id: The external account number (int) or account ID Guid. (required) 5488 :param AccountSignaturesInformation account_signatures_information: 5489 :return: AccountSignaturesInformation 5490 If the method is called asynchronously, 5491 returns the request thread. 5492 """ 5493 kwargs['_return_http_data_only'] = True 5494 if kwargs.get('callback'): 5495 return self.update_account_signature_with_http_info(account_id, **kwargs) 5496 else: 5497 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 5498 return data 5499 5500 def update_account_signature_with_http_info(self, account_id, **kwargs): 5501 """ 5502 Updates a account signature. 5503 5504 This method makes a synchronous HTTP request by default. To make an 5505 asynchronous HTTP request, please define a `callback` function 5506 to be invoked when receiving the response. 5507 >>> def callback_function(response): 5508 >>> pprint(response) 5509 >>> 5510 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 5511 5512 :param callback function: The callback function 5513 for asynchronous request. (optional) 5514 :param str account_id: The external account number (int) or account ID Guid. (required) 5515 :param AccountSignaturesInformation account_signatures_information: 5516 :return: AccountSignaturesInformation 5517 If the method is called asynchronously, 5518 returns the request thread. 5519 """ 5520 5521 all_params = ['account_id', 'account_signatures_information'] 5522 all_params.append('callback') 5523 all_params.append('_return_http_data_only') 5524 all_params.append('_preload_content') 5525 all_params.append('_request_timeout') 5526 5527 params = locals() 5528 for key, val in iteritems(params['kwargs']): 5529 if key not in all_params: 5530 raise TypeError( 5531 "Got an unexpected keyword argument '%s'" 5532 " to method update_account_signature" % key 5533 ) 5534 params[key] = val 5535 del params['kwargs'] 5536 # verify the required parameter 'account_id' is set 5537 if ('account_id' not in params) or (params['account_id'] is None): 5538 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 5539 5540 5541 collection_formats = {} 5542 5543 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 5544 path_params = {} 5545 if 'account_id' in params: 5546 path_params['accountId'] = params['account_id'] 5547 5548 query_params = {} 5549 5550 header_params = {} 5551 5552 form_params = [] 5553 local_var_files = {} 5554 5555 body_params = None 5556 if 'account_signatures_information' in params: 5557 body_params = params['account_signatures_information'] 5558 # HTTP header `Accept` 5559 header_params['Accept'] = self.api_client.\ 5560 select_header_accept(['application/json']) 5561 5562 # Authentication setting 5563 auth_settings = [] 5564 5565 return self.api_client.call_api(resource_path, 'PUT', 5566 path_params, 5567 query_params, 5568 header_params, 5569 body=body_params, 5570 post_params=form_params, 5571 files=local_var_files, 5572 response_type='AccountSignaturesInformation', 5573 auth_settings=auth_settings, 5574 callback=params.get('callback'), 5575 _return_http_data_only=params.get('_return_http_data_only'), 5576 _preload_content=params.get('_preload_content', True), 5577 _request_timeout=params.get('_request_timeout'), 5578 collection_formats=collection_formats) 5579 5580 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 5581 """ 5582 Updates a account signature. 5583 5584 This method makes a synchronous HTTP request by default. To make an 5585 asynchronous HTTP request, please define a `callback` function 5586 to be invoked when receiving the response. 5587 >>> def callback_function(response): 5588 >>> pprint(response) 5589 >>> 5590 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 5591 5592 :param callback function: The callback function 5593 for asynchronous request. (optional) 5594 :param str account_id: The external account number (int) or account ID Guid. (required) 5595 :param str signature_id: The ID of the signature being accessed. (required) 5596 :param str close_existing_signature: 5597 :param AccountSignatureDefinition account_signature_definition: 5598 :return: AccountSignature 5599 If the method is called asynchronously, 5600 returns the request thread. 5601 """ 5602 kwargs['_return_http_data_only'] = True 5603 if kwargs.get('callback'): 5604 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 5605 else: 5606 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 5607 return data 5608 5609 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 5610 """ 5611 Updates a account signature. 5612 5613 This method makes a synchronous HTTP request by default. To make an 5614 asynchronous HTTP request, please define a `callback` function 5615 to be invoked when receiving the response. 5616 >>> def callback_function(response): 5617 >>> pprint(response) 5618 >>> 5619 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 5620 5621 :param callback function: The callback function 5622 for asynchronous request. (optional) 5623 :param str account_id: The external account number (int) or account ID Guid. (required) 5624 :param str signature_id: The ID of the signature being accessed. (required) 5625 :param str close_existing_signature: 5626 :param AccountSignatureDefinition account_signature_definition: 5627 :return: AccountSignature 5628 If the method is called asynchronously, 5629 returns the request thread. 5630 """ 5631 5632 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 5633 all_params.append('callback') 5634 all_params.append('_return_http_data_only') 5635 all_params.append('_preload_content') 5636 all_params.append('_request_timeout') 5637 5638 params = locals() 5639 for key, val in iteritems(params['kwargs']): 5640 if key not in all_params: 5641 raise TypeError( 5642 "Got an unexpected keyword argument '%s'" 5643 " to method update_account_signature_by_id" % key 5644 ) 5645 params[key] = val 5646 del params['kwargs'] 5647 # verify the required parameter 'account_id' is set 5648 if ('account_id' not in params) or (params['account_id'] is None): 5649 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 5650 # verify the required parameter 'signature_id' is set 5651 if ('signature_id' not in params) or (params['signature_id'] is None): 5652 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 5653 5654 5655 collection_formats = {} 5656 5657 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 5658 path_params = {} 5659 if 'account_id' in params: 5660 path_params['accountId'] = params['account_id'] 5661 if 'signature_id' in params: 5662 path_params['signatureId'] = params['signature_id'] 5663 5664 query_params = {} 5665 if 'close_existing_signature' in params: 5666 query_params['close_existing_signature'] = params['close_existing_signature'] 5667 5668 header_params = {} 5669 5670 form_params = [] 5671 local_var_files = {} 5672 5673 body_params = None 5674 if 'account_signature_definition' in params: 5675 body_params = params['account_signature_definition'] 5676 # HTTP header `Accept` 5677 header_params['Accept'] = self.api_client.\ 5678 select_header_accept(['application/json']) 5679 5680 # Authentication setting 5681 auth_settings = [] 5682 5683 return self.api_client.call_api(resource_path, 'PUT', 5684 path_params, 5685 query_params, 5686 header_params, 5687 body=body_params, 5688 post_params=form_params, 5689 files=local_var_files, 5690 response_type='AccountSignature', 5691 auth_settings=auth_settings, 5692 callback=params.get('callback'), 5693 _return_http_data_only=params.get('_return_http_data_only'), 5694 _preload_content=params.get('_preload_content', True), 5695 _request_timeout=params.get('_request_timeout'), 5696 collection_formats=collection_formats) 5697 5698 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 5699 """ 5700 Sets a signature, initials, or stamps image. 5701 5702 This method makes a synchronous HTTP request by default. To make an 5703 asynchronous HTTP request, please define a `callback` function 5704 to be invoked when receiving the response. 5705 >>> def callback_function(response): 5706 >>> pprint(response) 5707 >>> 5708 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 5709 5710 :param callback function: The callback function 5711 for asynchronous request. (optional) 5712 :param str account_id: The external account number (int) or account ID Guid. (required) 5713 :param str image_type: One of **signature_image** or **initials_image**. (required) 5714 :param str signature_id: The ID of the signature being accessed. (required) 5715 :param str transparent_png: 5716 :return: AccountSignature 5717 If the method is called asynchronously, 5718 returns the request thread. 5719 """ 5720 kwargs['_return_http_data_only'] = True 5721 if kwargs.get('callback'): 5722 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 5723 else: 5724 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 5725 return data 5726 5727 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 5728 """ 5729 Sets a signature, initials, or stamps image. 5730 5731 This method makes a synchronous HTTP request by default. To make an 5732 asynchronous HTTP request, please define a `callback` function 5733 to be invoked when receiving the response. 5734 >>> def callback_function(response): 5735 >>> pprint(response) 5736 >>> 5737 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 5738 5739 :param callback function: The callback function 5740 for asynchronous request. (optional) 5741 :param str account_id: The external account number (int) or account ID Guid. (required) 5742 :param str image_type: One of **signature_image** or **initials_image**. (required) 5743 :param str signature_id: The ID of the signature being accessed. (required) 5744 :param str transparent_png: 5745 :return: AccountSignature 5746 If the method is called asynchronously, 5747 returns the request thread. 5748 """ 5749 5750 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 5751 all_params.append('callback') 5752 all_params.append('_return_http_data_only') 5753 all_params.append('_preload_content') 5754 all_params.append('_request_timeout') 5755 5756 params = locals() 5757 for key, val in iteritems(params['kwargs']): 5758 if key not in all_params: 5759 raise TypeError( 5760 "Got an unexpected keyword argument '%s'" 5761 " to method update_account_signature_image" % key 5762 ) 5763 params[key] = val 5764 del params['kwargs'] 5765 # verify the required parameter 'account_id' is set 5766 if ('account_id' not in params) or (params['account_id'] is None): 5767 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 5768 # verify the required parameter 'image_type' is set 5769 if ('image_type' not in params) or (params['image_type'] is None): 5770 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 5771 # verify the required parameter 'signature_id' is set 5772 if ('signature_id' not in params) or (params['signature_id'] is None): 5773 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 5774 5775 5776 collection_formats = {} 5777 5778 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 5779 path_params = {} 5780 if 'account_id' in params: 5781 path_params['accountId'] = params['account_id'] 5782 if 'image_type' in params: 5783 path_params['imageType'] = params['image_type'] 5784 if 'signature_id' in params: 5785 path_params['signatureId'] = params['signature_id'] 5786 5787 query_params = {} 5788 if 'transparent_png' in params: 5789 query_params['transparent_png'] = params['transparent_png'] 5790 5791 header_params = {} 5792 5793 form_params = [] 5794 local_var_files = {} 5795 5796 body_params = None 5797 # HTTP header `Accept` 5798 header_params['Accept'] = self.api_client.\ 5799 select_header_accept(['application/json']) 5800 5801 # HTTP header `Content-Type` 5802 header_params['Content-Type'] = self.api_client.\ 5803 select_header_content_type(['image/gif']) 5804 5805 # Authentication setting 5806 auth_settings = [] 5807 5808 return self.api_client.call_api(resource_path, 'PUT', 5809 path_params, 5810 query_params, 5811 header_params, 5812 body=body_params, 5813 post_params=form_params, 5814 files=local_var_files, 5815 response_type='AccountSignature', 5816 auth_settings=auth_settings, 5817 callback=params.get('callback'), 5818 _return_http_data_only=params.get('_return_http_data_only'), 5819 _preload_content=params.get('_preload_content', True), 5820 _request_timeout=params.get('_request_timeout'), 5821 collection_formats=collection_formats) 5822 5823 def update_account_tab_settings(self, account_id, **kwargs): 5824 """ 5825 Modifies tab settings for specified account 5826 This method modifies the tab types and tab functionality that is enabled for an account. 5827 This method makes a synchronous HTTP request by default. To make an 5828 asynchronous HTTP request, please define a `callback` function 5829 to be invoked when receiving the response. 5830 >>> def callback_function(response): 5831 >>> pprint(response) 5832 >>> 5833 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 5834 5835 :param callback function: The callback function 5836 for asynchronous request. (optional) 5837 :param str account_id: The external account number (int) or account ID Guid. (required) 5838 :param TabAccountSettings tab_account_settings: 5839 :return: TabAccountSettings 5840 If the method is called asynchronously, 5841 returns the request thread. 5842 """ 5843 kwargs['_return_http_data_only'] = True 5844 if kwargs.get('callback'): 5845 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 5846 else: 5847 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 5848 return data 5849 5850 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 5851 """ 5852 Modifies tab settings for specified account 5853 This method modifies the tab types and tab functionality that is enabled for an account. 5854 This method makes a synchronous HTTP request by default. To make an 5855 asynchronous HTTP request, please define a `callback` function 5856 to be invoked when receiving the response. 5857 >>> def callback_function(response): 5858 >>> pprint(response) 5859 >>> 5860 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 5861 5862 :param callback function: The callback function 5863 for asynchronous request. (optional) 5864 :param str account_id: The external account number (int) or account ID Guid. (required) 5865 :param TabAccountSettings tab_account_settings: 5866 :return: TabAccountSettings 5867 If the method is called asynchronously, 5868 returns the request thread. 5869 """ 5870 5871 all_params = ['account_id', 'tab_account_settings'] 5872 all_params.append('callback') 5873 all_params.append('_return_http_data_only') 5874 all_params.append('_preload_content') 5875 all_params.append('_request_timeout') 5876 5877 params = locals() 5878 for key, val in iteritems(params['kwargs']): 5879 if key not in all_params: 5880 raise TypeError( 5881 "Got an unexpected keyword argument '%s'" 5882 " to method update_account_tab_settings" % key 5883 ) 5884 params[key] = val 5885 del params['kwargs'] 5886 # verify the required parameter 'account_id' is set 5887 if ('account_id' not in params) or (params['account_id'] is None): 5888 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 5889 5890 5891 collection_formats = {} 5892 5893 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 5894 path_params = {} 5895 if 'account_id' in params: 5896 path_params['accountId'] = params['account_id'] 5897 5898 query_params = {} 5899 5900 header_params = {} 5901 5902 form_params = [] 5903 local_var_files = {} 5904 5905 body_params = None 5906 if 'tab_account_settings' in params: 5907 body_params = params['tab_account_settings'] 5908 # HTTP header `Accept` 5909 header_params['Accept'] = self.api_client.\ 5910 select_header_accept(['application/json']) 5911 5912 # Authentication setting 5913 auth_settings = [] 5914 5915 return self.api_client.call_api(resource_path, 'PUT', 5916 path_params, 5917 query_params, 5918 header_params, 5919 body=body_params, 5920 post_params=form_params, 5921 files=local_var_files, 5922 response_type='TabAccountSettings', 5923 auth_settings=auth_settings, 5924 callback=params.get('callback'), 5925 _return_http_data_only=params.get('_return_http_data_only'), 5926 _preload_content=params.get('_preload_content', True), 5927 _request_timeout=params.get('_request_timeout'), 5928 collection_formats=collection_formats) 5929 5930 def update_brand(self, account_id, brand_id, **kwargs): 5931 """ 5932 Updates an existing brand. 5933 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 5934 This method makes a synchronous HTTP request by default. To make an 5935 asynchronous HTTP request, please define a `callback` function 5936 to be invoked when receiving the response. 5937 >>> def callback_function(response): 5938 >>> pprint(response) 5939 >>> 5940 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 5941 5942 :param callback function: The callback function 5943 for asynchronous request. (optional) 5944 :param str account_id: The external account number (int) or account ID Guid. (required) 5945 :param str brand_id: The unique identifier of a brand. (required) 5946 :param str replace_brand: 5947 :param Brand brand: 5948 :return: Brand 5949 If the method is called asynchronously, 5950 returns the request thread. 5951 """ 5952 kwargs['_return_http_data_only'] = True 5953 if kwargs.get('callback'): 5954 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 5955 else: 5956 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 5957 return data 5958 5959 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 5960 """ 5961 Updates an existing brand. 5962 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 5963 This method makes a synchronous HTTP request by default. To make an 5964 asynchronous HTTP request, please define a `callback` function 5965 to be invoked when receiving the response. 5966 >>> def callback_function(response): 5967 >>> pprint(response) 5968 >>> 5969 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 5970 5971 :param callback function: The callback function 5972 for asynchronous request. (optional) 5973 :param str account_id: The external account number (int) or account ID Guid. (required) 5974 :param str brand_id: The unique identifier of a brand. (required) 5975 :param str replace_brand: 5976 :param Brand brand: 5977 :return: Brand 5978 If the method is called asynchronously, 5979 returns the request thread. 5980 """ 5981 5982 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 5983 all_params.append('callback') 5984 all_params.append('_return_http_data_only') 5985 all_params.append('_preload_content') 5986 all_params.append('_request_timeout') 5987 5988 params = locals() 5989 for key, val in iteritems(params['kwargs']): 5990 if key not in all_params: 5991 raise TypeError( 5992 "Got an unexpected keyword argument '%s'" 5993 " to method update_brand" % key 5994 ) 5995 params[key] = val 5996 del params['kwargs'] 5997 # verify the required parameter 'account_id' is set 5998 if ('account_id' not in params) or (params['account_id'] is None): 5999 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6000 # verify the required parameter 'brand_id' is set 6001 if ('brand_id' not in params) or (params['brand_id'] is None): 6002 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6003 6004 6005 collection_formats = {} 6006 6007 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6008 path_params = {} 6009 if 'account_id' in params: 6010 path_params['accountId'] = params['account_id'] 6011 if 'brand_id' in params: 6012 path_params['brandId'] = params['brand_id'] 6013 6014 query_params = {} 6015 if 'replace_brand' in params: 6016 query_params['replace_brand'] = params['replace_brand'] 6017 6018 header_params = {} 6019 6020 form_params = [] 6021 local_var_files = {} 6022 6023 body_params = None 6024 if 'brand' in params: 6025 body_params = params['brand'] 6026 # HTTP header `Accept` 6027 header_params['Accept'] = self.api_client.\ 6028 select_header_accept(['application/json']) 6029 6030 # Authentication setting 6031 auth_settings = [] 6032 6033 return self.api_client.call_api(resource_path, 'PUT', 6034 path_params, 6035 query_params, 6036 header_params, 6037 body=body_params, 6038 post_params=form_params, 6039 files=local_var_files, 6040 response_type='Brand', 6041 auth_settings=auth_settings, 6042 callback=params.get('callback'), 6043 _return_http_data_only=params.get('_return_http_data_only'), 6044 _preload_content=params.get('_preload_content', True), 6045 _request_timeout=params.get('_request_timeout'), 6046 collection_formats=collection_formats) 6047 6048 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6049 """ 6050 Put one branding logo. 6051 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6052 This method makes a synchronous HTTP request by default. To make an 6053 asynchronous HTTP request, please define a `callback` function 6054 to be invoked when receiving the response. 6055 >>> def callback_function(response): 6056 >>> pprint(response) 6057 >>> 6058 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6059 6060 :param callback function: The callback function 6061 for asynchronous request. (optional) 6062 :param str account_id: The external account number (int) or account ID GUID. (required) 6063 :param str brand_id: The ID of the brand. (required) 6064 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6065 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6066 :return: None 6067 If the method is called asynchronously, 6068 returns the request thread. 6069 """ 6070 kwargs['_return_http_data_only'] = True 6071 if kwargs.get('callback'): 6072 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6073 else: 6074 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6075 return data 6076 6077 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6078 """ 6079 Put one branding logo. 6080 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6081 This method makes a synchronous HTTP request by default. To make an 6082 asynchronous HTTP request, please define a `callback` function 6083 to be invoked when receiving the response. 6084 >>> def callback_function(response): 6085 >>> pprint(response) 6086 >>> 6087 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6088 6089 :param callback function: The callback function 6090 for asynchronous request. (optional) 6091 :param str account_id: The external account number (int) or account ID GUID. (required) 6092 :param str brand_id: The ID of the brand. (required) 6093 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6094 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6095 :return: None 6096 If the method is called asynchronously, 6097 returns the request thread. 6098 """ 6099 6100 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6101 all_params.append('callback') 6102 all_params.append('_return_http_data_only') 6103 all_params.append('_preload_content') 6104 all_params.append('_request_timeout') 6105 6106 params = locals() 6107 for key, val in iteritems(params['kwargs']): 6108 if key not in all_params: 6109 raise TypeError( 6110 "Got an unexpected keyword argument '%s'" 6111 " to method update_brand_logo_by_type" % key 6112 ) 6113 params[key] = val 6114 del params['kwargs'] 6115 # verify the required parameter 'account_id' is set 6116 if ('account_id' not in params) or (params['account_id'] is None): 6117 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6118 # verify the required parameter 'brand_id' is set 6119 if ('brand_id' not in params) or (params['brand_id'] is None): 6120 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6121 # verify the required parameter 'logo_type' is set 6122 if ('logo_type' not in params) or (params['logo_type'] is None): 6123 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6124 # verify the required parameter 'logo_file_bytes' is set 6125 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6126 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6127 6128 6129 collection_formats = {} 6130 6131 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6132 path_params = {} 6133 if 'account_id' in params: 6134 path_params['accountId'] = params['account_id'] 6135 if 'brand_id' in params: 6136 path_params['brandId'] = params['brand_id'] 6137 if 'logo_type' in params: 6138 path_params['logoType'] = params['logo_type'] 6139 6140 query_params = {} 6141 6142 header_params = {} 6143 6144 form_params = [] 6145 local_var_files = {} 6146 6147 body_params = None 6148 if 'logo_file_bytes' in params: 6149 body_params = params['logo_file_bytes'] 6150 # HTTP header `Accept` 6151 header_params['Accept'] = self.api_client.\ 6152 select_header_accept(['application/json']) 6153 6154 # HTTP header `Content-Type` 6155 header_params['Content-Type'] = self.api_client.\ 6156 select_header_content_type(['image/png']) 6157 6158 # Authentication setting 6159 auth_settings = [] 6160 6161 return self.api_client.call_api(resource_path, 'PUT', 6162 path_params, 6163 query_params, 6164 header_params, 6165 body=body_params, 6166 post_params=form_params, 6167 files=local_var_files, 6168 response_type=None, 6169 auth_settings=auth_settings, 6170 callback=params.get('callback'), 6171 _return_http_data_only=params.get('_return_http_data_only'), 6172 _preload_content=params.get('_preload_content', True), 6173 _request_timeout=params.get('_request_timeout'), 6174 collection_formats=collection_formats) 6175 6176 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 6177 """ 6178 Uploads a branding resource file. 6179 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 6180 This method makes a synchronous HTTP request by default. To make an 6181 asynchronous HTTP request, please define a `callback` function 6182 to be invoked when receiving the response. 6183 >>> def callback_function(response): 6184 >>> pprint(response) 6185 >>> 6186 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 6187 6188 :param callback function: The callback function 6189 for asynchronous request. (optional) 6190 :param str account_id: The external account number (int) or account ID GUID. (required) 6191 :param str brand_id: The ID of the brand. (required) 6192 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 6193 :param file file_xml: Brand resource XML file. (required) 6194 :return: BrandResources 6195 If the method is called asynchronously, 6196 returns the request thread. 6197 """ 6198 kwargs['_return_http_data_only'] = True 6199 if kwargs.get('callback'): 6200 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 6201 else: 6202 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 6203 return data 6204 6205 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 6206 """ 6207 Uploads a branding resource file. 6208 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 6209 This method makes a synchronous HTTP request by default. To make an 6210 asynchronous HTTP request, please define a `callback` function 6211 to be invoked when receiving the response. 6212 >>> def callback_function(response): 6213 >>> pprint(response) 6214 >>> 6215 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 6216 6217 :param callback function: The callback function 6218 for asynchronous request. (optional) 6219 :param str account_id: The external account number (int) or account ID GUID. (required) 6220 :param str brand_id: The ID of the brand. (required) 6221 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 6222 :param file file_xml: Brand resource XML file. (required) 6223 :return: BrandResources 6224 If the method is called asynchronously, 6225 returns the request thread. 6226 """ 6227 6228 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 6229 all_params.append('callback') 6230 all_params.append('_return_http_data_only') 6231 all_params.append('_preload_content') 6232 all_params.append('_request_timeout') 6233 6234 params = locals() 6235 for key, val in iteritems(params['kwargs']): 6236 if key not in all_params: 6237 raise TypeError( 6238 "Got an unexpected keyword argument '%s'" 6239 " to method update_brand_resources_by_content_type" % key 6240 ) 6241 params[key] = val 6242 del params['kwargs'] 6243 # verify the required parameter 'account_id' is set 6244 if ('account_id' not in params) or (params['account_id'] is None): 6245 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 6246 # verify the required parameter 'brand_id' is set 6247 if ('brand_id' not in params) or (params['brand_id'] is None): 6248 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 6249 # verify the required parameter 'resource_content_type' is set 6250 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 6251 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 6252 # verify the required parameter 'file_xml' is set 6253 if ('file_xml' not in params) or (params['file_xml'] is None): 6254 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 6255 6256 6257 collection_formats = {} 6258 6259 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 6260 path_params = {} 6261 if 'account_id' in params: 6262 path_params['accountId'] = params['account_id'] 6263 if 'brand_id' in params: 6264 path_params['brandId'] = params['brand_id'] 6265 if 'resource_content_type' in params: 6266 path_params['resourceContentType'] = params['resource_content_type'] 6267 6268 query_params = {} 6269 6270 header_params = {} 6271 6272 form_params = [] 6273 local_var_files = {} 6274 if 'file_xml' in params: 6275 local_var_files['file.xml'] = params['file_xml'] 6276 6277 body_params = None 6278 # HTTP header `Accept` 6279 header_params['Accept'] = self.api_client.\ 6280 select_header_accept(['application/json']) 6281 6282 # HTTP header `Content-Type` 6283 header_params['Content-Type'] = self.api_client.\ 6284 select_header_content_type(['multipart/form-data']) 6285 6286 # Authentication setting 6287 auth_settings = [] 6288 6289 return self.api_client.call_api(resource_path, 'PUT', 6290 path_params, 6291 query_params, 6292 header_params, 6293 body=body_params, 6294 post_params=form_params, 6295 files=local_var_files, 6296 response_type='BrandResources', 6297 auth_settings=auth_settings, 6298 callback=params.get('callback'), 6299 _return_http_data_only=params.get('_return_http_data_only'), 6300 _preload_content=params.get('_preload_content', True), 6301 _request_timeout=params.get('_request_timeout'), 6302 collection_formats=collection_formats) 6303 6304 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 6305 """ 6306 Update Consumer Disclosure. 6307 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 6308 This method makes a synchronous HTTP request by default. To make an 6309 asynchronous HTTP request, please define a `callback` function 6310 to be invoked when receiving the response. 6311 >>> def callback_function(response): 6312 >>> pprint(response) 6313 >>> 6314 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 6315 6316 :param callback function: The callback function 6317 for asynchronous request. (optional) 6318 :param str account_id: The external account number (int) or account ID Guid. (required) 6319 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6320 :param str include_metadata: 6321 :param ConsumerDisclosure consumer_disclosure: 6322 :return: ConsumerDisclosure 6323 If the method is called asynchronously, 6324 returns the request thread. 6325 """ 6326 kwargs['_return_http_data_only'] = True 6327 if kwargs.get('callback'): 6328 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 6329 else: 6330 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 6331 return data 6332 6333 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 6334 """ 6335 Update Consumer Disclosure. 6336 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 6337 This method makes a synchronous HTTP request by default. To make an 6338 asynchronous HTTP request, please define a `callback` function 6339 to be invoked when receiving the response. 6340 >>> def callback_function(response): 6341 >>> pprint(response) 6342 >>> 6343 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 6344 6345 :param callback function: The callback function 6346 for asynchronous request. (optional) 6347 :param str account_id: The external account number (int) or account ID Guid. (required) 6348 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6349 :param str include_metadata: 6350 :param ConsumerDisclosure consumer_disclosure: 6351 :return: ConsumerDisclosure 6352 If the method is called asynchronously, 6353 returns the request thread. 6354 """ 6355 6356 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 6357 all_params.append('callback') 6358 all_params.append('_return_http_data_only') 6359 all_params.append('_preload_content') 6360 all_params.append('_request_timeout') 6361 6362 params = locals() 6363 for key, val in iteritems(params['kwargs']): 6364 if key not in all_params: 6365 raise TypeError( 6366 "Got an unexpected keyword argument '%s'" 6367 " to method update_consumer_disclosure" % key 6368 ) 6369 params[key] = val 6370 del params['kwargs'] 6371 # verify the required parameter 'account_id' is set 6372 if ('account_id' not in params) or (params['account_id'] is None): 6373 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 6374 # verify the required parameter 'lang_code' is set 6375 if ('lang_code' not in params) or (params['lang_code'] is None): 6376 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 6377 6378 6379 collection_formats = {} 6380 6381 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6382 path_params = {} 6383 if 'account_id' in params: 6384 path_params['accountId'] = params['account_id'] 6385 if 'lang_code' in params: 6386 path_params['langCode'] = params['lang_code'] 6387 6388 query_params = {} 6389 if 'include_metadata' in params: 6390 query_params['include_metadata'] = params['include_metadata'] 6391 6392 header_params = {} 6393 6394 form_params = [] 6395 local_var_files = {} 6396 6397 body_params = None 6398 if 'consumer_disclosure' in params: 6399 body_params = params['consumer_disclosure'] 6400 # HTTP header `Accept` 6401 header_params['Accept'] = self.api_client.\ 6402 select_header_accept(['application/json']) 6403 6404 # Authentication setting 6405 auth_settings = [] 6406 6407 return self.api_client.call_api(resource_path, 'PUT', 6408 path_params, 6409 query_params, 6410 header_params, 6411 body=body_params, 6412 post_params=form_params, 6413 files=local_var_files, 6414 response_type='ConsumerDisclosure', 6415 auth_settings=auth_settings, 6416 callback=params.get('callback'), 6417 _return_http_data_only=params.get('_return_http_data_only'), 6418 _preload_content=params.get('_preload_content', True), 6419 _request_timeout=params.get('_request_timeout'), 6420 collection_formats=collection_formats) 6421 6422 def update_custom_field(self, account_id, custom_field_id, **kwargs): 6423 """ 6424 Updates an existing account custom field. 6425 This method updates an existing account custom field. 6426 This method makes a synchronous HTTP request by default. To make an 6427 asynchronous HTTP request, please define a `callback` function 6428 to be invoked when receiving the response. 6429 >>> def callback_function(response): 6430 >>> pprint(response) 6431 >>> 6432 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 6433 6434 :param callback function: The callback function 6435 for asynchronous request. (optional) 6436 :param str account_id: The external account number (int) or account ID Guid. (required) 6437 :param str custom_field_id: (required) 6438 :param str apply_to_templates: 6439 :param CustomField custom_field: 6440 :return: CustomFields 6441 If the method is called asynchronously, 6442 returns the request thread. 6443 """ 6444 kwargs['_return_http_data_only'] = True 6445 if kwargs.get('callback'): 6446 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 6447 else: 6448 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 6449 return data 6450 6451 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 6452 """ 6453 Updates an existing account custom field. 6454 This method updates an existing account custom field. 6455 This method makes a synchronous HTTP request by default. To make an 6456 asynchronous HTTP request, please define a `callback` function 6457 to be invoked when receiving the response. 6458 >>> def callback_function(response): 6459 >>> pprint(response) 6460 >>> 6461 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 6462 6463 :param callback function: The callback function 6464 for asynchronous request. (optional) 6465 :param str account_id: The external account number (int) or account ID Guid. (required) 6466 :param str custom_field_id: (required) 6467 :param str apply_to_templates: 6468 :param CustomField custom_field: 6469 :return: CustomFields 6470 If the method is called asynchronously, 6471 returns the request thread. 6472 """ 6473 6474 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 6475 all_params.append('callback') 6476 all_params.append('_return_http_data_only') 6477 all_params.append('_preload_content') 6478 all_params.append('_request_timeout') 6479 6480 params = locals() 6481 for key, val in iteritems(params['kwargs']): 6482 if key not in all_params: 6483 raise TypeError( 6484 "Got an unexpected keyword argument '%s'" 6485 " to method update_custom_field" % key 6486 ) 6487 params[key] = val 6488 del params['kwargs'] 6489 # verify the required parameter 'account_id' is set 6490 if ('account_id' not in params) or (params['account_id'] is None): 6491 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 6492 # verify the required parameter 'custom_field_id' is set 6493 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 6494 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 6495 6496 6497 collection_formats = {} 6498 6499 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 6500 path_params = {} 6501 if 'account_id' in params: 6502 path_params['accountId'] = params['account_id'] 6503 if 'custom_field_id' in params: 6504 path_params['customFieldId'] = params['custom_field_id'] 6505 6506 query_params = {} 6507 if 'apply_to_templates' in params: 6508 query_params['apply_to_templates'] = params['apply_to_templates'] 6509 6510 header_params = {} 6511 6512 form_params = [] 6513 local_var_files = {} 6514 6515 body_params = None 6516 if 'custom_field' in params: 6517 body_params = params['custom_field'] 6518 # HTTP header `Accept` 6519 header_params['Accept'] = self.api_client.\ 6520 select_header_accept(['application/json']) 6521 6522 # Authentication setting 6523 auth_settings = [] 6524 6525 return self.api_client.call_api(resource_path, 'PUT', 6526 path_params, 6527 query_params, 6528 header_params, 6529 body=body_params, 6530 post_params=form_params, 6531 files=local_var_files, 6532 response_type='CustomFields', 6533 auth_settings=auth_settings, 6534 callback=params.get('callback'), 6535 _return_http_data_only=params.get('_return_http_data_only'), 6536 _preload_content=params.get('_preload_content', True), 6537 _request_timeout=params.get('_request_timeout'), 6538 collection_formats=collection_formats) 6539 6540 def update_e_note_configuration(self, account_id, **kwargs): 6541 """ 6542 Updates configuration information for the eNote eOriginal integration. 6543 6544 This method makes a synchronous HTTP request by default. To make an 6545 asynchronous HTTP request, please define a `callback` function 6546 to be invoked when receiving the response. 6547 >>> def callback_function(response): 6548 >>> pprint(response) 6549 >>> 6550 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 6551 6552 :param callback function: The callback function 6553 for asynchronous request. (optional) 6554 :param str account_id: The external account number (int) or account ID Guid. (required) 6555 :param ENoteConfiguration e_note_configuration: 6556 :return: ENoteConfiguration 6557 If the method is called asynchronously, 6558 returns the request thread. 6559 """ 6560 kwargs['_return_http_data_only'] = True 6561 if kwargs.get('callback'): 6562 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 6563 else: 6564 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 6565 return data 6566 6567 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 6568 """ 6569 Updates configuration information for the eNote eOriginal integration. 6570 6571 This method makes a synchronous HTTP request by default. To make an 6572 asynchronous HTTP request, please define a `callback` function 6573 to be invoked when receiving the response. 6574 >>> def callback_function(response): 6575 >>> pprint(response) 6576 >>> 6577 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 6578 6579 :param callback function: The callback function 6580 for asynchronous request. (optional) 6581 :param str account_id: The external account number (int) or account ID Guid. (required) 6582 :param ENoteConfiguration e_note_configuration: 6583 :return: ENoteConfiguration 6584 If the method is called asynchronously, 6585 returns the request thread. 6586 """ 6587 6588 all_params = ['account_id', 'e_note_configuration'] 6589 all_params.append('callback') 6590 all_params.append('_return_http_data_only') 6591 all_params.append('_preload_content') 6592 all_params.append('_request_timeout') 6593 6594 params = locals() 6595 for key, val in iteritems(params['kwargs']): 6596 if key not in all_params: 6597 raise TypeError( 6598 "Got an unexpected keyword argument '%s'" 6599 " to method update_e_note_configuration" % key 6600 ) 6601 params[key] = val 6602 del params['kwargs'] 6603 # verify the required parameter 'account_id' is set 6604 if ('account_id' not in params) or (params['account_id'] is None): 6605 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 6606 6607 6608 collection_formats = {} 6609 6610 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 6611 path_params = {} 6612 if 'account_id' in params: 6613 path_params['accountId'] = params['account_id'] 6614 6615 query_params = {} 6616 6617 header_params = {} 6618 6619 form_params = [] 6620 local_var_files = {} 6621 6622 body_params = None 6623 if 'e_note_configuration' in params: 6624 body_params = params['e_note_configuration'] 6625 # HTTP header `Accept` 6626 header_params['Accept'] = self.api_client.\ 6627 select_header_accept(['application/json']) 6628 6629 # Authentication setting 6630 auth_settings = [] 6631 6632 return self.api_client.call_api(resource_path, 'PUT', 6633 path_params, 6634 query_params, 6635 header_params, 6636 body=body_params, 6637 post_params=form_params, 6638 files=local_var_files, 6639 response_type='ENoteConfiguration', 6640 auth_settings=auth_settings, 6641 callback=params.get('callback'), 6642 _return_http_data_only=params.get('_return_http_data_only'), 6643 _preload_content=params.get('_preload_content', True), 6644 _request_timeout=params.get('_request_timeout'), 6645 collection_formats=collection_formats) 6646 6647 def update_envelope_purge_configuration(self, account_id, **kwargs): 6648 """ 6649 Updates envelope purge configuration. 6650 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 6651 This method makes a synchronous HTTP request by default. To make an 6652 asynchronous HTTP request, please define a `callback` function 6653 to be invoked when receiving the response. 6654 >>> def callback_function(response): 6655 >>> pprint(response) 6656 >>> 6657 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 6658 6659 :param callback function: The callback function 6660 for asynchronous request. (optional) 6661 :param str account_id: The external account number (int) or account ID Guid. (required) 6662 :param EnvelopePurgeConfiguration envelope_purge_configuration: 6663 :return: EnvelopePurgeConfiguration 6664 If the method is called asynchronously, 6665 returns the request thread. 6666 """ 6667 kwargs['_return_http_data_only'] = True 6668 if kwargs.get('callback'): 6669 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 6670 else: 6671 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 6672 return data 6673 6674 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 6675 """ 6676 Updates envelope purge configuration. 6677 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 6678 This method makes a synchronous HTTP request by default. To make an 6679 asynchronous HTTP request, please define a `callback` function 6680 to be invoked when receiving the response. 6681 >>> def callback_function(response): 6682 >>> pprint(response) 6683 >>> 6684 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 6685 6686 :param callback function: The callback function 6687 for asynchronous request. (optional) 6688 :param str account_id: The external account number (int) or account ID Guid. (required) 6689 :param EnvelopePurgeConfiguration envelope_purge_configuration: 6690 :return: EnvelopePurgeConfiguration 6691 If the method is called asynchronously, 6692 returns the request thread. 6693 """ 6694 6695 all_params = ['account_id', 'envelope_purge_configuration'] 6696 all_params.append('callback') 6697 all_params.append('_return_http_data_only') 6698 all_params.append('_preload_content') 6699 all_params.append('_request_timeout') 6700 6701 params = locals() 6702 for key, val in iteritems(params['kwargs']): 6703 if key not in all_params: 6704 raise TypeError( 6705 "Got an unexpected keyword argument '%s'" 6706 " to method update_envelope_purge_configuration" % key 6707 ) 6708 params[key] = val 6709 del params['kwargs'] 6710 # verify the required parameter 'account_id' is set 6711 if ('account_id' not in params) or (params['account_id'] is None): 6712 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 6713 6714 6715 collection_formats = {} 6716 6717 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 6718 path_params = {} 6719 if 'account_id' in params: 6720 path_params['accountId'] = params['account_id'] 6721 6722 query_params = {} 6723 6724 header_params = {} 6725 6726 form_params = [] 6727 local_var_files = {} 6728 6729 body_params = None 6730 if 'envelope_purge_configuration' in params: 6731 body_params = params['envelope_purge_configuration'] 6732 # HTTP header `Accept` 6733 header_params['Accept'] = self.api_client.\ 6734 select_header_accept(['application/json']) 6735 6736 # Authentication setting 6737 auth_settings = [] 6738 6739 return self.api_client.call_api(resource_path, 'PUT', 6740 path_params, 6741 query_params, 6742 header_params, 6743 body=body_params, 6744 post_params=form_params, 6745 files=local_var_files, 6746 response_type='EnvelopePurgeConfiguration', 6747 auth_settings=auth_settings, 6748 callback=params.get('callback'), 6749 _return_http_data_only=params.get('_return_http_data_only'), 6750 _preload_content=params.get('_preload_content', True), 6751 _request_timeout=params.get('_request_timeout'), 6752 collection_formats=collection_formats) 6753 6754 def update_favorite_template(self, account_id, **kwargs): 6755 """ 6756 Favorites a template 6757 6758 This method makes a synchronous HTTP request by default. To make an 6759 asynchronous HTTP request, please define a `callback` function 6760 to be invoked when receiving the response. 6761 >>> def callback_function(response): 6762 >>> pprint(response) 6763 >>> 6764 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 6765 6766 :param callback function: The callback function 6767 for asynchronous request. (optional) 6768 :param str account_id: The external account number (int) or account ID Guid. (required) 6769 :param FavoriteTemplatesInfo favorite_templates_info: 6770 :return: FavoriteTemplatesInfo 6771 If the method is called asynchronously, 6772 returns the request thread. 6773 """ 6774 kwargs['_return_http_data_only'] = True 6775 if kwargs.get('callback'): 6776 return self.update_favorite_template_with_http_info(account_id, **kwargs) 6777 else: 6778 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 6779 return data 6780 6781 def update_favorite_template_with_http_info(self, account_id, **kwargs): 6782 """ 6783 Favorites a template 6784 6785 This method makes a synchronous HTTP request by default. To make an 6786 asynchronous HTTP request, please define a `callback` function 6787 to be invoked when receiving the response. 6788 >>> def callback_function(response): 6789 >>> pprint(response) 6790 >>> 6791 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 6792 6793 :param callback function: The callback function 6794 for asynchronous request. (optional) 6795 :param str account_id: The external account number (int) or account ID Guid. (required) 6796 :param FavoriteTemplatesInfo favorite_templates_info: 6797 :return: FavoriteTemplatesInfo 6798 If the method is called asynchronously, 6799 returns the request thread. 6800 """ 6801 6802 all_params = ['account_id', 'favorite_templates_info'] 6803 all_params.append('callback') 6804 all_params.append('_return_http_data_only') 6805 all_params.append('_preload_content') 6806 all_params.append('_request_timeout') 6807 6808 params = locals() 6809 for key, val in iteritems(params['kwargs']): 6810 if key not in all_params: 6811 raise TypeError( 6812 "Got an unexpected keyword argument '%s'" 6813 " to method update_favorite_template" % key 6814 ) 6815 params[key] = val 6816 del params['kwargs'] 6817 # verify the required parameter 'account_id' is set 6818 if ('account_id' not in params) or (params['account_id'] is None): 6819 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 6820 6821 6822 collection_formats = {} 6823 6824 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6825 path_params = {} 6826 if 'account_id' in params: 6827 path_params['accountId'] = params['account_id'] 6828 6829 query_params = {} 6830 6831 header_params = {} 6832 6833 form_params = [] 6834 local_var_files = {} 6835 6836 body_params = None 6837 if 'favorite_templates_info' in params: 6838 body_params = params['favorite_templates_info'] 6839 # HTTP header `Accept` 6840 header_params['Accept'] = self.api_client.\ 6841 select_header_accept(['application/json']) 6842 6843 # Authentication setting 6844 auth_settings = [] 6845 6846 return self.api_client.call_api(resource_path, 'PUT', 6847 path_params, 6848 query_params, 6849 header_params, 6850 body=body_params, 6851 post_params=form_params, 6852 files=local_var_files, 6853 response_type='FavoriteTemplatesInfo', 6854 auth_settings=auth_settings, 6855 callback=params.get('callback'), 6856 _return_http_data_only=params.get('_return_http_data_only'), 6857 _preload_content=params.get('_preload_content', True), 6858 _request_timeout=params.get('_request_timeout'), 6859 collection_formats=collection_formats) 6860 6861 def update_notification_defaults(self, account_id, **kwargs): 6862 """ 6863 Updates default user level settings for a specified account 6864 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 6865 This method makes a synchronous HTTP request by default. To make an 6866 asynchronous HTTP request, please define a `callback` function 6867 to be invoked when receiving the response. 6868 >>> def callback_function(response): 6869 >>> pprint(response) 6870 >>> 6871 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 6872 6873 :param callback function: The callback function 6874 for asynchronous request. (optional) 6875 :param str account_id: The external account number (int) or account ID Guid. (required) 6876 :param NotificationDefaults notification_defaults: 6877 :return: NotificationDefaults 6878 If the method is called asynchronously, 6879 returns the request thread. 6880 """ 6881 kwargs['_return_http_data_only'] = True 6882 if kwargs.get('callback'): 6883 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 6884 else: 6885 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 6886 return data 6887 6888 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 6889 """ 6890 Updates default user level settings for a specified account 6891 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 6892 This method makes a synchronous HTTP request by default. To make an 6893 asynchronous HTTP request, please define a `callback` function 6894 to be invoked when receiving the response. 6895 >>> def callback_function(response): 6896 >>> pprint(response) 6897 >>> 6898 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 6899 6900 :param callback function: The callback function 6901 for asynchronous request. (optional) 6902 :param str account_id: The external account number (int) or account ID Guid. (required) 6903 :param NotificationDefaults notification_defaults: 6904 :return: NotificationDefaults 6905 If the method is called asynchronously, 6906 returns the request thread. 6907 """ 6908 6909 all_params = ['account_id', 'notification_defaults'] 6910 all_params.append('callback') 6911 all_params.append('_return_http_data_only') 6912 all_params.append('_preload_content') 6913 all_params.append('_request_timeout') 6914 6915 params = locals() 6916 for key, val in iteritems(params['kwargs']): 6917 if key not in all_params: 6918 raise TypeError( 6919 "Got an unexpected keyword argument '%s'" 6920 " to method update_notification_defaults" % key 6921 ) 6922 params[key] = val 6923 del params['kwargs'] 6924 # verify the required parameter 'account_id' is set 6925 if ('account_id' not in params) or (params['account_id'] is None): 6926 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 6927 6928 6929 collection_formats = {} 6930 6931 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 6932 path_params = {} 6933 if 'account_id' in params: 6934 path_params['accountId'] = params['account_id'] 6935 6936 query_params = {} 6937 6938 header_params = {} 6939 6940 form_params = [] 6941 local_var_files = {} 6942 6943 body_params = None 6944 if 'notification_defaults' in params: 6945 body_params = params['notification_defaults'] 6946 # HTTP header `Accept` 6947 header_params['Accept'] = self.api_client.\ 6948 select_header_accept(['application/json']) 6949 6950 # Authentication setting 6951 auth_settings = [] 6952 6953 return self.api_client.call_api(resource_path, 'PUT', 6954 path_params, 6955 query_params, 6956 header_params, 6957 body=body_params, 6958 post_params=form_params, 6959 files=local_var_files, 6960 response_type='NotificationDefaults', 6961 auth_settings=auth_settings, 6962 callback=params.get('callback'), 6963 _return_http_data_only=params.get('_return_http_data_only'), 6964 _preload_content=params.get('_preload_content', True), 6965 _request_timeout=params.get('_request_timeout'), 6966 collection_formats=collection_formats) 6967 6968 def update_password_rules(self, account_id, **kwargs): 6969 """ 6970 Update the password rules 6971 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 6972 This method makes a synchronous HTTP request by default. To make an 6973 asynchronous HTTP request, please define a `callback` function 6974 to be invoked when receiving the response. 6975 >>> def callback_function(response): 6976 >>> pprint(response) 6977 >>> 6978 >>> thread = api.update_password_rules(account_id, callback=callback_function) 6979 6980 :param callback function: The callback function 6981 for asynchronous request. (optional) 6982 :param str account_id: The external account number (int) or account ID Guid. (required) 6983 :param AccountPasswordRules account_password_rules: 6984 :return: AccountPasswordRules 6985 If the method is called asynchronously, 6986 returns the request thread. 6987 """ 6988 kwargs['_return_http_data_only'] = True 6989 if kwargs.get('callback'): 6990 return self.update_password_rules_with_http_info(account_id, **kwargs) 6991 else: 6992 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 6993 return data 6994 6995 def update_password_rules_with_http_info(self, account_id, **kwargs): 6996 """ 6997 Update the password rules 6998 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 6999 This method makes a synchronous HTTP request by default. To make an 7000 asynchronous HTTP request, please define a `callback` function 7001 to be invoked when receiving the response. 7002 >>> def callback_function(response): 7003 >>> pprint(response) 7004 >>> 7005 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7006 7007 :param callback function: The callback function 7008 for asynchronous request. (optional) 7009 :param str account_id: The external account number (int) or account ID Guid. (required) 7010 :param AccountPasswordRules account_password_rules: 7011 :return: AccountPasswordRules 7012 If the method is called asynchronously, 7013 returns the request thread. 7014 """ 7015 7016 all_params = ['account_id', 'account_password_rules'] 7017 all_params.append('callback') 7018 all_params.append('_return_http_data_only') 7019 all_params.append('_preload_content') 7020 all_params.append('_request_timeout') 7021 7022 params = locals() 7023 for key, val in iteritems(params['kwargs']): 7024 if key not in all_params: 7025 raise TypeError( 7026 "Got an unexpected keyword argument '%s'" 7027 " to method update_password_rules" % key 7028 ) 7029 params[key] = val 7030 del params['kwargs'] 7031 # verify the required parameter 'account_id' is set 7032 if ('account_id' not in params) or (params['account_id'] is None): 7033 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7034 7035 7036 collection_formats = {} 7037 7038 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7039 path_params = {} 7040 if 'account_id' in params: 7041 path_params['accountId'] = params['account_id'] 7042 7043 query_params = {} 7044 7045 header_params = {} 7046 7047 form_params = [] 7048 local_var_files = {} 7049 7050 body_params = None 7051 if 'account_password_rules' in params: 7052 body_params = params['account_password_rules'] 7053 # HTTP header `Accept` 7054 header_params['Accept'] = self.api_client.\ 7055 select_header_accept(['application/json']) 7056 7057 # Authentication setting 7058 auth_settings = [] 7059 7060 return self.api_client.call_api(resource_path, 'PUT', 7061 path_params, 7062 query_params, 7063 header_params, 7064 body=body_params, 7065 post_params=form_params, 7066 files=local_var_files, 7067 response_type='AccountPasswordRules', 7068 auth_settings=auth_settings, 7069 callback=params.get('callback'), 7070 _return_http_data_only=params.get('_return_http_data_only'), 7071 _preload_content=params.get('_preload_content', True), 7072 _request_timeout=params.get('_request_timeout'), 7073 collection_formats=collection_formats) 7074 7075 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7076 """ 7077 Updates a permission profile within the specified account. 7078 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7079 This method makes a synchronous HTTP request by default. To make an 7080 asynchronous HTTP request, please define a `callback` function 7081 to be invoked when receiving the response. 7082 >>> def callback_function(response): 7083 >>> pprint(response) 7084 >>> 7085 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7086 7087 :param callback function: The callback function 7088 for asynchronous request. (optional) 7089 :param str account_id: The external account number (int) or account ID Guid. (required) 7090 :param str permission_profile_id: (required) 7091 :param str include: 7092 :param PermissionProfile permission_profile: 7093 :return: PermissionProfile 7094 If the method is called asynchronously, 7095 returns the request thread. 7096 """ 7097 kwargs['_return_http_data_only'] = True 7098 if kwargs.get('callback'): 7099 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7100 else: 7101 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7102 return data 7103 7104 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7105 """ 7106 Updates a permission profile within the specified account. 7107 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7108 This method makes a synchronous HTTP request by default. To make an 7109 asynchronous HTTP request, please define a `callback` function 7110 to be invoked when receiving the response. 7111 >>> def callback_function(response): 7112 >>> pprint(response) 7113 >>> 7114 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7115 7116 :param callback function: The callback function 7117 for asynchronous request. (optional) 7118 :param str account_id: The external account number (int) or account ID Guid. (required) 7119 :param str permission_profile_id: (required) 7120 :param str include: 7121 :param PermissionProfile permission_profile: 7122 :return: PermissionProfile 7123 If the method is called asynchronously, 7124 returns the request thread. 7125 """ 7126 7127 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7128 all_params.append('callback') 7129 all_params.append('_return_http_data_only') 7130 all_params.append('_preload_content') 7131 all_params.append('_request_timeout') 7132 7133 params = locals() 7134 for key, val in iteritems(params['kwargs']): 7135 if key not in all_params: 7136 raise TypeError( 7137 "Got an unexpected keyword argument '%s'" 7138 " to method update_permission_profile" % key 7139 ) 7140 params[key] = val 7141 del params['kwargs'] 7142 # verify the required parameter 'account_id' is set 7143 if ('account_id' not in params) or (params['account_id'] is None): 7144 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7145 # verify the required parameter 'permission_profile_id' is set 7146 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7147 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7148 7149 7150 collection_formats = {} 7151 7152 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 7153 path_params = {} 7154 if 'account_id' in params: 7155 path_params['accountId'] = params['account_id'] 7156 if 'permission_profile_id' in params: 7157 path_params['permissionProfileId'] = params['permission_profile_id'] 7158 7159 query_params = {} 7160 if 'include' in params: 7161 query_params['include'] = params['include'] 7162 7163 header_params = {} 7164 7165 form_params = [] 7166 local_var_files = {} 7167 7168 body_params = None 7169 if 'permission_profile' in params: 7170 body_params = params['permission_profile'] 7171 # HTTP header `Accept` 7172 header_params['Accept'] = self.api_client.\ 7173 select_header_accept(['application/json']) 7174 7175 # Authentication setting 7176 auth_settings = [] 7177 7178 return self.api_client.call_api(resource_path, 'PUT', 7179 path_params, 7180 query_params, 7181 header_params, 7182 body=body_params, 7183 post_params=form_params, 7184 files=local_var_files, 7185 response_type='PermissionProfile', 7186 auth_settings=auth_settings, 7187 callback=params.get('callback'), 7188 _return_http_data_only=params.get('_return_http_data_only'), 7189 _preload_content=params.get('_preload_content', True), 7190 _request_timeout=params.get('_request_timeout'), 7191 collection_formats=collection_formats) 7192 7193 def update_settings(self, account_id, **kwargs): 7194 """ 7195 Updates the account settings for an account. 7196 Updates the account settings for the specified account. 7197 This method makes a synchronous HTTP request by default. To make an 7198 asynchronous HTTP request, please define a `callback` function 7199 to be invoked when receiving the response. 7200 >>> def callback_function(response): 7201 >>> pprint(response) 7202 >>> 7203 >>> thread = api.update_settings(account_id, callback=callback_function) 7204 7205 :param callback function: The callback function 7206 for asynchronous request. (optional) 7207 :param str account_id: The external account number (int) or account ID Guid. (required) 7208 :param AccountSettingsInformation account_settings_information: 7209 :return: None 7210 If the method is called asynchronously, 7211 returns the request thread. 7212 """ 7213 kwargs['_return_http_data_only'] = True 7214 if kwargs.get('callback'): 7215 return self.update_settings_with_http_info(account_id, **kwargs) 7216 else: 7217 (data) = self.update_settings_with_http_info(account_id, **kwargs) 7218 return data 7219 7220 def update_settings_with_http_info(self, account_id, **kwargs): 7221 """ 7222 Updates the account settings for an account. 7223 Updates the account settings for the specified account. 7224 This method makes a synchronous HTTP request by default. To make an 7225 asynchronous HTTP request, please define a `callback` function 7226 to be invoked when receiving the response. 7227 >>> def callback_function(response): 7228 >>> pprint(response) 7229 >>> 7230 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 7231 7232 :param callback function: The callback function 7233 for asynchronous request. (optional) 7234 :param str account_id: The external account number (int) or account ID Guid. (required) 7235 :param AccountSettingsInformation account_settings_information: 7236 :return: None 7237 If the method is called asynchronously, 7238 returns the request thread. 7239 """ 7240 7241 all_params = ['account_id', 'account_settings_information'] 7242 all_params.append('callback') 7243 all_params.append('_return_http_data_only') 7244 all_params.append('_preload_content') 7245 all_params.append('_request_timeout') 7246 7247 params = locals() 7248 for key, val in iteritems(params['kwargs']): 7249 if key not in all_params: 7250 raise TypeError( 7251 "Got an unexpected keyword argument '%s'" 7252 " to method update_settings" % key 7253 ) 7254 params[key] = val 7255 del params['kwargs'] 7256 # verify the required parameter 'account_id' is set 7257 if ('account_id' not in params) or (params['account_id'] is None): 7258 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 7259 7260 7261 collection_formats = {} 7262 7263 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 7264 path_params = {} 7265 if 'account_id' in params: 7266 path_params['accountId'] = params['account_id'] 7267 7268 query_params = {} 7269 7270 header_params = {} 7271 7272 form_params = [] 7273 local_var_files = {} 7274 7275 body_params = None 7276 if 'account_settings_information' in params: 7277 body_params = params['account_settings_information'] 7278 # HTTP header `Accept` 7279 header_params['Accept'] = self.api_client.\ 7280 select_header_accept(['application/json']) 7281 7282 # Authentication setting 7283 auth_settings = [] 7284 7285 return self.api_client.call_api(resource_path, 'PUT', 7286 path_params, 7287 query_params, 7288 header_params, 7289 body=body_params, 7290 post_params=form_params, 7291 files=local_var_files, 7292 response_type=None, 7293 auth_settings=auth_settings, 7294 callback=params.get('callback'), 7295 _return_http_data_only=params.get('_return_http_data_only'), 7296 _preload_content=params.get('_preload_content', True), 7297 _request_timeout=params.get('_request_timeout'), 7298 collection_formats=collection_formats) 7299 7300 def update_shared_access(self, account_id, **kwargs): 7301 """ 7302 Reserved: Sets the shared access information for users. 7303 Reserved: Sets the shared access information for one or more users. 7304 This method makes a synchronous HTTP request by default. To make an 7305 asynchronous HTTP request, please define a `callback` function 7306 to be invoked when receiving the response. 7307 >>> def callback_function(response): 7308 >>> pprint(response) 7309 >>> 7310 >>> thread = api.update_shared_access(account_id, callback=callback_function) 7311 7312 :param callback function: The callback function 7313 for asynchronous request. (optional) 7314 :param str account_id: The external account number (int) or account ID Guid. (required) 7315 :param str item_type: 7316 :param str preserve_existing_shared_access: 7317 :param str user_ids: 7318 :param AccountSharedAccess account_shared_access: 7319 :return: AccountSharedAccess 7320 If the method is called asynchronously, 7321 returns the request thread. 7322 """ 7323 kwargs['_return_http_data_only'] = True 7324 if kwargs.get('callback'): 7325 return self.update_shared_access_with_http_info(account_id, **kwargs) 7326 else: 7327 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 7328 return data 7329 7330 def update_shared_access_with_http_info(self, account_id, **kwargs): 7331 """ 7332 Reserved: Sets the shared access information for users. 7333 Reserved: Sets the shared access information for one or more users. 7334 This method makes a synchronous HTTP request by default. To make an 7335 asynchronous HTTP request, please define a `callback` function 7336 to be invoked when receiving the response. 7337 >>> def callback_function(response): 7338 >>> pprint(response) 7339 >>> 7340 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 7341 7342 :param callback function: The callback function 7343 for asynchronous request. (optional) 7344 :param str account_id: The external account number (int) or account ID Guid. (required) 7345 :param str item_type: 7346 :param str preserve_existing_shared_access: 7347 :param str user_ids: 7348 :param AccountSharedAccess account_shared_access: 7349 :return: AccountSharedAccess 7350 If the method is called asynchronously, 7351 returns the request thread. 7352 """ 7353 7354 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 7355 all_params.append('callback') 7356 all_params.append('_return_http_data_only') 7357 all_params.append('_preload_content') 7358 all_params.append('_request_timeout') 7359 7360 params = locals() 7361 for key, val in iteritems(params['kwargs']): 7362 if key not in all_params: 7363 raise TypeError( 7364 "Got an unexpected keyword argument '%s'" 7365 " to method update_shared_access" % key 7366 ) 7367 params[key] = val 7368 del params['kwargs'] 7369 # verify the required parameter 'account_id' is set 7370 if ('account_id' not in params) or (params['account_id'] is None): 7371 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 7372 7373 7374 collection_formats = {} 7375 7376 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 7377 path_params = {} 7378 if 'account_id' in params: 7379 path_params['accountId'] = params['account_id'] 7380 7381 query_params = {} 7382 if 'item_type' in params: 7383 query_params['item_type'] = params['item_type'] 7384 if 'preserve_existing_shared_access' in params: 7385 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 7386 if 'user_ids' in params: 7387 query_params['user_ids'] = params['user_ids'] 7388 7389 header_params = {} 7390 7391 form_params = [] 7392 local_var_files = {} 7393 7394 body_params = None 7395 if 'account_shared_access' in params: 7396 body_params = params['account_shared_access'] 7397 # HTTP header `Accept` 7398 header_params['Accept'] = self.api_client.\ 7399 select_header_accept(['application/json']) 7400 7401 # Authentication setting 7402 auth_settings = [] 7403 7404 return self.api_client.call_api(resource_path, 'PUT', 7405 path_params, 7406 query_params, 7407 header_params, 7408 body=body_params, 7409 post_params=form_params, 7410 files=local_var_files, 7411 response_type='AccountSharedAccess', 7412 auth_settings=auth_settings, 7413 callback=params.get('callback'), 7414 _return_http_data_only=params.get('_return_http_data_only'), 7415 _preload_content=params.get('_preload_content', True), 7416 _request_timeout=params.get('_request_timeout'), 7417 collection_formats=collection_formats) 7418 7419 def update_watermark(self, account_id, **kwargs): 7420 """ 7421 Update watermark information. 7422 7423 This method makes a synchronous HTTP request by default. To make an 7424 asynchronous HTTP request, please define a `callback` function 7425 to be invoked when receiving the response. 7426 >>> def callback_function(response): 7427 >>> pprint(response) 7428 >>> 7429 >>> thread = api.update_watermark(account_id, callback=callback_function) 7430 7431 :param callback function: The callback function 7432 for asynchronous request. (optional) 7433 :param str account_id: The external account number (int) or account ID Guid. (required) 7434 :param Watermark watermark: 7435 :return: Watermark 7436 If the method is called asynchronously, 7437 returns the request thread. 7438 """ 7439 kwargs['_return_http_data_only'] = True 7440 if kwargs.get('callback'): 7441 return self.update_watermark_with_http_info(account_id, **kwargs) 7442 else: 7443 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 7444 return data 7445 7446 def update_watermark_with_http_info(self, account_id, **kwargs): 7447 """ 7448 Update watermark information. 7449 7450 This method makes a synchronous HTTP request by default. To make an 7451 asynchronous HTTP request, please define a `callback` function 7452 to be invoked when receiving the response. 7453 >>> def callback_function(response): 7454 >>> pprint(response) 7455 >>> 7456 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 7457 7458 :param callback function: The callback function 7459 for asynchronous request. (optional) 7460 :param str account_id: The external account number (int) or account ID Guid. (required) 7461 :param Watermark watermark: 7462 :return: Watermark 7463 If the method is called asynchronously, 7464 returns the request thread. 7465 """ 7466 7467 all_params = ['account_id', 'watermark'] 7468 all_params.append('callback') 7469 all_params.append('_return_http_data_only') 7470 all_params.append('_preload_content') 7471 all_params.append('_request_timeout') 7472 7473 params = locals() 7474 for key, val in iteritems(params['kwargs']): 7475 if key not in all_params: 7476 raise TypeError( 7477 "Got an unexpected keyword argument '%s'" 7478 " to method update_watermark" % key 7479 ) 7480 params[key] = val 7481 del params['kwargs'] 7482 # verify the required parameter 'account_id' is set 7483 if ('account_id' not in params) or (params['account_id'] is None): 7484 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 7485 7486 7487 collection_formats = {} 7488 7489 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 7490 path_params = {} 7491 if 'account_id' in params: 7492 path_params['accountId'] = params['account_id'] 7493 7494 query_params = {} 7495 7496 header_params = {} 7497 7498 form_params = [] 7499 local_var_files = {} 7500 7501 body_params = None 7502 if 'watermark' in params: 7503 body_params = params['watermark'] 7504 # HTTP header `Accept` 7505 header_params['Accept'] = self.api_client.\ 7506 select_header_accept(['application/json']) 7507 7508 # Authentication setting 7509 auth_settings = [] 7510 7511 return self.api_client.call_api(resource_path, 'PUT', 7512 path_params, 7513 query_params, 7514 header_params, 7515 body=body_params, 7516 post_params=form_params, 7517 files=local_var_files, 7518 response_type='Watermark', 7519 auth_settings=auth_settings, 7520 callback=params.get('callback'), 7521 _return_http_data_only=params.get('_return_http_data_only'), 7522 _preload_content=params.get('_preload_content', True), 7523 _request_timeout=params.get('_request_timeout'), 7524 collection_formats=collection_formats)
class
AccountsApi:
28class AccountsApi(object): 29 """ 30 NOTE: This class is auto generated by the swagger code generator program. 31 Do not edit the class manually. 32 Ref: https://github.com/swagger-api/swagger-codegen 33 """ 34 35 def __init__(self, api_client=None): 36 config = Configuration() 37 if api_client: 38 self.api_client = api_client 39 else: 40 if not config.api_client: 41 config.api_client = ApiClient() 42 self.api_client = config.api_client 43 44 def create(self, **kwargs): 45 """ 46 Creates new accounts. 47 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 48 This method makes a synchronous HTTP request by default. To make an 49 asynchronous HTTP request, please define a `callback` function 50 to be invoked when receiving the response. 51 >>> def callback_function(response): 52 >>> pprint(response) 53 >>> 54 >>> thread = api.create(callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 59 :param NewAccountDefinition new_account_definition: 60 :return: NewAccountSummary 61 If the method is called asynchronously, 62 returns the request thread. 63 """ 64 kwargs['_return_http_data_only'] = True 65 if kwargs.get('callback'): 66 return self.create_with_http_info(**kwargs) 67 else: 68 (data) = self.create_with_http_info(**kwargs) 69 return data 70 71 def create_with_http_info(self, **kwargs): 72 """ 73 Creates new accounts. 74 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 75 This method makes a synchronous HTTP request by default. To make an 76 asynchronous HTTP request, please define a `callback` function 77 to be invoked when receiving the response. 78 >>> def callback_function(response): 79 >>> pprint(response) 80 >>> 81 >>> thread = api.create_with_http_info(callback=callback_function) 82 83 :param callback function: The callback function 84 for asynchronous request. (optional) 85 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 86 :param NewAccountDefinition new_account_definition: 87 :return: NewAccountSummary 88 If the method is called asynchronously, 89 returns the request thread. 90 """ 91 92 all_params = ['preview_billing_plan', 'new_account_definition'] 93 all_params.append('callback') 94 all_params.append('_return_http_data_only') 95 all_params.append('_preload_content') 96 all_params.append('_request_timeout') 97 98 params = locals() 99 for key, val in iteritems(params['kwargs']): 100 if key not in all_params: 101 raise TypeError( 102 "Got an unexpected keyword argument '%s'" 103 " to method create" % key 104 ) 105 params[key] = val 106 del params['kwargs'] 107 108 109 collection_formats = {} 110 111 resource_path = '/v2.1/accounts'.replace('{format}', 'json') 112 path_params = {} 113 114 query_params = {} 115 if 'preview_billing_plan' in params: 116 query_params['preview_billing_plan'] = params['preview_billing_plan'] 117 118 header_params = {} 119 120 form_params = [] 121 local_var_files = {} 122 123 body_params = None 124 if 'new_account_definition' in params: 125 body_params = params['new_account_definition'] 126 # HTTP header `Accept` 127 header_params['Accept'] = self.api_client.\ 128 select_header_accept(['application/json']) 129 130 # Authentication setting 131 auth_settings = [] 132 133 return self.api_client.call_api(resource_path, 'POST', 134 path_params, 135 query_params, 136 header_params, 137 body=body_params, 138 post_params=form_params, 139 files=local_var_files, 140 response_type='NewAccountSummary', 141 auth_settings=auth_settings, 142 callback=params.get('callback'), 143 _return_http_data_only=params.get('_return_http_data_only'), 144 _preload_content=params.get('_preload_content', True), 145 _request_timeout=params.get('_request_timeout'), 146 collection_formats=collection_formats) 147 148 def create_account_signatures(self, account_id, **kwargs): 149 """ 150 Adds/updates one or more account signatures. This request may include images in multi-part format. 151 152 This method makes a synchronous HTTP request by default. To make an 153 asynchronous HTTP request, please define a `callback` function 154 to be invoked when receiving the response. 155 >>> def callback_function(response): 156 >>> pprint(response) 157 >>> 158 >>> thread = api.create_account_signatures(account_id, callback=callback_function) 159 160 :param callback function: The callback function 161 for asynchronous request. (optional) 162 :param str account_id: The external account number (int) or account ID Guid. (required) 163 :param str decode_only: 164 :param AccountSignaturesInformation account_signatures_information: 165 :return: AccountSignaturesInformation 166 If the method is called asynchronously, 167 returns the request thread. 168 """ 169 kwargs['_return_http_data_only'] = True 170 if kwargs.get('callback'): 171 return self.create_account_signatures_with_http_info(account_id, **kwargs) 172 else: 173 (data) = self.create_account_signatures_with_http_info(account_id, **kwargs) 174 return data 175 176 def create_account_signatures_with_http_info(self, account_id, **kwargs): 177 """ 178 Adds/updates one or more account signatures. This request may include images in multi-part format. 179 180 This method makes a synchronous HTTP request by default. To make an 181 asynchronous HTTP request, please define a `callback` function 182 to be invoked when receiving the response. 183 >>> def callback_function(response): 184 >>> pprint(response) 185 >>> 186 >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function) 187 188 :param callback function: The callback function 189 for asynchronous request. (optional) 190 :param str account_id: The external account number (int) or account ID Guid. (required) 191 :param str decode_only: 192 :param AccountSignaturesInformation account_signatures_information: 193 :return: AccountSignaturesInformation 194 If the method is called asynchronously, 195 returns the request thread. 196 """ 197 198 all_params = ['account_id', 'decode_only', 'account_signatures_information'] 199 all_params.append('callback') 200 all_params.append('_return_http_data_only') 201 all_params.append('_preload_content') 202 all_params.append('_request_timeout') 203 204 params = locals() 205 for key, val in iteritems(params['kwargs']): 206 if key not in all_params: 207 raise TypeError( 208 "Got an unexpected keyword argument '%s'" 209 " to method create_account_signatures" % key 210 ) 211 params[key] = val 212 del params['kwargs'] 213 # verify the required parameter 'account_id' is set 214 if ('account_id' not in params) or (params['account_id'] is None): 215 raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`") 216 217 218 collection_formats = {} 219 220 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 221 path_params = {} 222 if 'account_id' in params: 223 path_params['accountId'] = params['account_id'] 224 225 query_params = {} 226 if 'decode_only' in params: 227 query_params['decode_only'] = params['decode_only'] 228 229 header_params = {} 230 231 form_params = [] 232 local_var_files = {} 233 234 body_params = None 235 if 'account_signatures_information' in params: 236 body_params = params['account_signatures_information'] 237 # HTTP header `Accept` 238 header_params['Accept'] = self.api_client.\ 239 select_header_accept(['application/json']) 240 241 # Authentication setting 242 auth_settings = [] 243 244 return self.api_client.call_api(resource_path, 'POST', 245 path_params, 246 query_params, 247 header_params, 248 body=body_params, 249 post_params=form_params, 250 files=local_var_files, 251 response_type='AccountSignaturesInformation', 252 auth_settings=auth_settings, 253 callback=params.get('callback'), 254 _return_http_data_only=params.get('_return_http_data_only'), 255 _preload_content=params.get('_preload_content', True), 256 _request_timeout=params.get('_request_timeout'), 257 collection_formats=collection_formats) 258 259 def create_brand(self, account_id, **kwargs): 260 """ 261 Creates one or more brand profile files for the account. 262 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 263 This method makes a synchronous HTTP request by default. To make an 264 asynchronous HTTP request, please define a `callback` function 265 to be invoked when receiving the response. 266 >>> def callback_function(response): 267 >>> pprint(response) 268 >>> 269 >>> thread = api.create_brand(account_id, callback=callback_function) 270 271 :param callback function: The callback function 272 for asynchronous request. (optional) 273 :param str account_id: The external account number (int) or account ID GUID. (required) 274 :param Brand brand: 275 :return: BrandsResponse 276 If the method is called asynchronously, 277 returns the request thread. 278 """ 279 kwargs['_return_http_data_only'] = True 280 if kwargs.get('callback'): 281 return self.create_brand_with_http_info(account_id, **kwargs) 282 else: 283 (data) = self.create_brand_with_http_info(account_id, **kwargs) 284 return data 285 286 def create_brand_with_http_info(self, account_id, **kwargs): 287 """ 288 Creates one or more brand profile files for the account. 289 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 290 This method makes a synchronous HTTP request by default. To make an 291 asynchronous HTTP request, please define a `callback` function 292 to be invoked when receiving the response. 293 >>> def callback_function(response): 294 >>> pprint(response) 295 >>> 296 >>> thread = api.create_brand_with_http_info(account_id, callback=callback_function) 297 298 :param callback function: The callback function 299 for asynchronous request. (optional) 300 :param str account_id: The external account number (int) or account ID GUID. (required) 301 :param Brand brand: 302 :return: BrandsResponse 303 If the method is called asynchronously, 304 returns the request thread. 305 """ 306 307 all_params = ['account_id', 'brand'] 308 all_params.append('callback') 309 all_params.append('_return_http_data_only') 310 all_params.append('_preload_content') 311 all_params.append('_request_timeout') 312 313 params = locals() 314 for key, val in iteritems(params['kwargs']): 315 if key not in all_params: 316 raise TypeError( 317 "Got an unexpected keyword argument '%s'" 318 " to method create_brand" % key 319 ) 320 params[key] = val 321 del params['kwargs'] 322 # verify the required parameter 'account_id' is set 323 if ('account_id' not in params) or (params['account_id'] is None): 324 raise ValueError("Missing the required parameter `account_id` when calling `create_brand`") 325 326 327 collection_formats = {} 328 329 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 330 path_params = {} 331 if 'account_id' in params: 332 path_params['accountId'] = params['account_id'] 333 334 query_params = {} 335 336 header_params = {} 337 338 form_params = [] 339 local_var_files = {} 340 341 body_params = None 342 if 'brand' in params: 343 body_params = params['brand'] 344 # HTTP header `Accept` 345 header_params['Accept'] = self.api_client.\ 346 select_header_accept(['application/json']) 347 348 # Authentication setting 349 auth_settings = [] 350 351 return self.api_client.call_api(resource_path, 'POST', 352 path_params, 353 query_params, 354 header_params, 355 body=body_params, 356 post_params=form_params, 357 files=local_var_files, 358 response_type='BrandsResponse', 359 auth_settings=auth_settings, 360 callback=params.get('callback'), 361 _return_http_data_only=params.get('_return_http_data_only'), 362 _preload_content=params.get('_preload_content', True), 363 _request_timeout=params.get('_request_timeout'), 364 collection_formats=collection_formats) 365 366 def create_custom_field(self, account_id, **kwargs): 367 """ 368 Creates an acount custom field. 369 This method creates a custom field and makes it available for all new envelopes associated with an account. 370 This method makes a synchronous HTTP request by default. To make an 371 asynchronous HTTP request, please define a `callback` function 372 to be invoked when receiving the response. 373 >>> def callback_function(response): 374 >>> pprint(response) 375 >>> 376 >>> thread = api.create_custom_field(account_id, callback=callback_function) 377 378 :param callback function: The callback function 379 for asynchronous request. (optional) 380 :param str account_id: The external account number (int) or account ID Guid. (required) 381 :param str apply_to_templates: 382 :param CustomField custom_field: 383 :return: CustomFields 384 If the method is called asynchronously, 385 returns the request thread. 386 """ 387 kwargs['_return_http_data_only'] = True 388 if kwargs.get('callback'): 389 return self.create_custom_field_with_http_info(account_id, **kwargs) 390 else: 391 (data) = self.create_custom_field_with_http_info(account_id, **kwargs) 392 return data 393 394 def create_custom_field_with_http_info(self, account_id, **kwargs): 395 """ 396 Creates an acount custom field. 397 This method creates a custom field and makes it available for all new envelopes associated with an account. 398 This method makes a synchronous HTTP request by default. To make an 399 asynchronous HTTP request, please define a `callback` function 400 to be invoked when receiving the response. 401 >>> def callback_function(response): 402 >>> pprint(response) 403 >>> 404 >>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function) 405 406 :param callback function: The callback function 407 for asynchronous request. (optional) 408 :param str account_id: The external account number (int) or account ID Guid. (required) 409 :param str apply_to_templates: 410 :param CustomField custom_field: 411 :return: CustomFields 412 If the method is called asynchronously, 413 returns the request thread. 414 """ 415 416 all_params = ['account_id', 'apply_to_templates', 'custom_field'] 417 all_params.append('callback') 418 all_params.append('_return_http_data_only') 419 all_params.append('_preload_content') 420 all_params.append('_request_timeout') 421 422 params = locals() 423 for key, val in iteritems(params['kwargs']): 424 if key not in all_params: 425 raise TypeError( 426 "Got an unexpected keyword argument '%s'" 427 " to method create_custom_field" % key 428 ) 429 params[key] = val 430 del params['kwargs'] 431 # verify the required parameter 'account_id' is set 432 if ('account_id' not in params) or (params['account_id'] is None): 433 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`") 434 435 436 collection_formats = {} 437 438 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 439 path_params = {} 440 if 'account_id' in params: 441 path_params['accountId'] = params['account_id'] 442 443 query_params = {} 444 if 'apply_to_templates' in params: 445 query_params['apply_to_templates'] = params['apply_to_templates'] 446 447 header_params = {} 448 449 form_params = [] 450 local_var_files = {} 451 452 body_params = None 453 if 'custom_field' in params: 454 body_params = params['custom_field'] 455 # HTTP header `Accept` 456 header_params['Accept'] = self.api_client.\ 457 select_header_accept(['application/json']) 458 459 # Authentication setting 460 auth_settings = [] 461 462 return self.api_client.call_api(resource_path, 'POST', 463 path_params, 464 query_params, 465 header_params, 466 body=body_params, 467 post_params=form_params, 468 files=local_var_files, 469 response_type='CustomFields', 470 auth_settings=auth_settings, 471 callback=params.get('callback'), 472 _return_http_data_only=params.get('_return_http_data_only'), 473 _preload_content=params.get('_preload_content', True), 474 _request_timeout=params.get('_request_timeout'), 475 collection_formats=collection_formats) 476 477 def create_permission_profile(self, account_id, **kwargs): 478 """ 479 Creates a new permission profile in the specified account. 480 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 481 This method makes a synchronous HTTP request by default. To make an 482 asynchronous HTTP request, please define a `callback` function 483 to be invoked when receiving the response. 484 >>> def callback_function(response): 485 >>> pprint(response) 486 >>> 487 >>> thread = api.create_permission_profile(account_id, callback=callback_function) 488 489 :param callback function: The callback function 490 for asynchronous request. (optional) 491 :param str account_id: The external account number (int) or account ID Guid. (required) 492 :param str include: 493 :param PermissionProfile permission_profile: 494 :return: PermissionProfile 495 If the method is called asynchronously, 496 returns the request thread. 497 """ 498 kwargs['_return_http_data_only'] = True 499 if kwargs.get('callback'): 500 return self.create_permission_profile_with_http_info(account_id, **kwargs) 501 else: 502 (data) = self.create_permission_profile_with_http_info(account_id, **kwargs) 503 return data 504 505 def create_permission_profile_with_http_info(self, account_id, **kwargs): 506 """ 507 Creates a new permission profile in the specified account. 508 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 509 This method makes a synchronous HTTP request by default. To make an 510 asynchronous HTTP request, please define a `callback` function 511 to be invoked when receiving the response. 512 >>> def callback_function(response): 513 >>> pprint(response) 514 >>> 515 >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function) 516 517 :param callback function: The callback function 518 for asynchronous request. (optional) 519 :param str account_id: The external account number (int) or account ID Guid. (required) 520 :param str include: 521 :param PermissionProfile permission_profile: 522 :return: PermissionProfile 523 If the method is called asynchronously, 524 returns the request thread. 525 """ 526 527 all_params = ['account_id', 'include', 'permission_profile'] 528 all_params.append('callback') 529 all_params.append('_return_http_data_only') 530 all_params.append('_preload_content') 531 all_params.append('_request_timeout') 532 533 params = locals() 534 for key, val in iteritems(params['kwargs']): 535 if key not in all_params: 536 raise TypeError( 537 "Got an unexpected keyword argument '%s'" 538 " to method create_permission_profile" % key 539 ) 540 params[key] = val 541 del params['kwargs'] 542 # verify the required parameter 'account_id' is set 543 if ('account_id' not in params) or (params['account_id'] is None): 544 raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`") 545 546 547 collection_formats = {} 548 549 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 550 path_params = {} 551 if 'account_id' in params: 552 path_params['accountId'] = params['account_id'] 553 554 query_params = {} 555 if 'include' in params: 556 query_params['include'] = params['include'] 557 558 header_params = {} 559 560 form_params = [] 561 local_var_files = {} 562 563 body_params = None 564 if 'permission_profile' in params: 565 body_params = params['permission_profile'] 566 # HTTP header `Accept` 567 header_params['Accept'] = self.api_client.\ 568 select_header_accept(['application/json']) 569 570 # Authentication setting 571 auth_settings = [] 572 573 return self.api_client.call_api(resource_path, 'POST', 574 path_params, 575 query_params, 576 header_params, 577 body=body_params, 578 post_params=form_params, 579 files=local_var_files, 580 response_type='PermissionProfile', 581 auth_settings=auth_settings, 582 callback=params.get('callback'), 583 _return_http_data_only=params.get('_return_http_data_only'), 584 _preload_content=params.get('_preload_content', True), 585 _request_timeout=params.get('_request_timeout'), 586 collection_formats=collection_formats) 587 588 def delete(self, account_id, **kwargs): 589 """ 590 Deletes the specified account. 591 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 592 This method makes a synchronous HTTP request by default. To make an 593 asynchronous HTTP request, please define a `callback` function 594 to be invoked when receiving the response. 595 >>> def callback_function(response): 596 >>> pprint(response) 597 >>> 598 >>> thread = api.delete(account_id, callback=callback_function) 599 600 :param callback function: The callback function 601 for asynchronous request. (optional) 602 :param str account_id: The external account number (int) or account ID Guid. (required) 603 :return: None 604 If the method is called asynchronously, 605 returns the request thread. 606 """ 607 kwargs['_return_http_data_only'] = True 608 if kwargs.get('callback'): 609 return self.delete_with_http_info(account_id, **kwargs) 610 else: 611 (data) = self.delete_with_http_info(account_id, **kwargs) 612 return data 613 614 def delete_with_http_info(self, account_id, **kwargs): 615 """ 616 Deletes the specified account. 617 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 618 This method makes a synchronous HTTP request by default. To make an 619 asynchronous HTTP request, please define a `callback` function 620 to be invoked when receiving the response. 621 >>> def callback_function(response): 622 >>> pprint(response) 623 >>> 624 >>> thread = api.delete_with_http_info(account_id, callback=callback_function) 625 626 :param callback function: The callback function 627 for asynchronous request. (optional) 628 :param str account_id: The external account number (int) or account ID Guid. (required) 629 :return: None 630 If the method is called asynchronously, 631 returns the request thread. 632 """ 633 634 all_params = ['account_id'] 635 all_params.append('callback') 636 all_params.append('_return_http_data_only') 637 all_params.append('_preload_content') 638 all_params.append('_request_timeout') 639 640 params = locals() 641 for key, val in iteritems(params['kwargs']): 642 if key not in all_params: 643 raise TypeError( 644 "Got an unexpected keyword argument '%s'" 645 " to method delete" % key 646 ) 647 params[key] = val 648 del params['kwargs'] 649 # verify the required parameter 'account_id' is set 650 if ('account_id' not in params) or (params['account_id'] is None): 651 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 652 653 654 collection_formats = {} 655 656 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 657 path_params = {} 658 if 'account_id' in params: 659 path_params['accountId'] = params['account_id'] 660 661 query_params = {} 662 663 header_params = {} 664 665 form_params = [] 666 local_var_files = {} 667 668 body_params = None 669 # HTTP header `Accept` 670 header_params['Accept'] = self.api_client.\ 671 select_header_accept(['application/json']) 672 673 # Authentication setting 674 auth_settings = [] 675 676 return self.api_client.call_api(resource_path, 'DELETE', 677 path_params, 678 query_params, 679 header_params, 680 body=body_params, 681 post_params=form_params, 682 files=local_var_files, 683 response_type=None, 684 auth_settings=auth_settings, 685 callback=params.get('callback'), 686 _return_http_data_only=params.get('_return_http_data_only'), 687 _preload_content=params.get('_preload_content', True), 688 _request_timeout=params.get('_request_timeout'), 689 collection_formats=collection_formats) 690 691 def delete_account_signature(self, account_id, signature_id, **kwargs): 692 """ 693 Close the specified signature by Id. 694 695 This method makes a synchronous HTTP request by default. To make an 696 asynchronous HTTP request, please define a `callback` function 697 to be invoked when receiving the response. 698 >>> def callback_function(response): 699 >>> pprint(response) 700 >>> 701 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 702 703 :param callback function: The callback function 704 for asynchronous request. (optional) 705 :param str account_id: The external account number (int) or account ID Guid. (required) 706 :param str signature_id: The ID of the signature being accessed. (required) 707 :return: None 708 If the method is called asynchronously, 709 returns the request thread. 710 """ 711 kwargs['_return_http_data_only'] = True 712 if kwargs.get('callback'): 713 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 714 else: 715 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 716 return data 717 718 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 719 """ 720 Close the specified signature by Id. 721 722 This method makes a synchronous HTTP request by default. To make an 723 asynchronous HTTP request, please define a `callback` function 724 to be invoked when receiving the response. 725 >>> def callback_function(response): 726 >>> pprint(response) 727 >>> 728 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 729 730 :param callback function: The callback function 731 for asynchronous request. (optional) 732 :param str account_id: The external account number (int) or account ID Guid. (required) 733 :param str signature_id: The ID of the signature being accessed. (required) 734 :return: None 735 If the method is called asynchronously, 736 returns the request thread. 737 """ 738 739 all_params = ['account_id', 'signature_id'] 740 all_params.append('callback') 741 all_params.append('_return_http_data_only') 742 all_params.append('_preload_content') 743 all_params.append('_request_timeout') 744 745 params = locals() 746 for key, val in iteritems(params['kwargs']): 747 if key not in all_params: 748 raise TypeError( 749 "Got an unexpected keyword argument '%s'" 750 " to method delete_account_signature" % key 751 ) 752 params[key] = val 753 del params['kwargs'] 754 # verify the required parameter 'account_id' is set 755 if ('account_id' not in params) or (params['account_id'] is None): 756 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 757 # verify the required parameter 'signature_id' is set 758 if ('signature_id' not in params) or (params['signature_id'] is None): 759 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 760 761 762 collection_formats = {} 763 764 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 765 path_params = {} 766 if 'account_id' in params: 767 path_params['accountId'] = params['account_id'] 768 if 'signature_id' in params: 769 path_params['signatureId'] = params['signature_id'] 770 771 query_params = {} 772 773 header_params = {} 774 775 form_params = [] 776 local_var_files = {} 777 778 body_params = None 779 # HTTP header `Accept` 780 header_params['Accept'] = self.api_client.\ 781 select_header_accept(['application/json']) 782 783 # Authentication setting 784 auth_settings = [] 785 786 return self.api_client.call_api(resource_path, 'DELETE', 787 path_params, 788 query_params, 789 header_params, 790 body=body_params, 791 post_params=form_params, 792 files=local_var_files, 793 response_type=None, 794 auth_settings=auth_settings, 795 callback=params.get('callback'), 796 _return_http_data_only=params.get('_return_http_data_only'), 797 _preload_content=params.get('_preload_content', True), 798 _request_timeout=params.get('_request_timeout'), 799 collection_formats=collection_formats) 800 801 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 802 """ 803 Deletes a signature, initials, or stamps image. 804 805 This method makes a synchronous HTTP request by default. To make an 806 asynchronous HTTP request, please define a `callback` function 807 to be invoked when receiving the response. 808 >>> def callback_function(response): 809 >>> pprint(response) 810 >>> 811 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 812 813 :param callback function: The callback function 814 for asynchronous request. (optional) 815 :param str account_id: The external account number (int) or account ID Guid. (required) 816 :param str image_type: One of **signature_image** or **initials_image**. (required) 817 :param str signature_id: The ID of the signature being accessed. (required) 818 :return: AccountSignature 819 If the method is called asynchronously, 820 returns the request thread. 821 """ 822 kwargs['_return_http_data_only'] = True 823 if kwargs.get('callback'): 824 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 825 else: 826 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 827 return data 828 829 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 830 """ 831 Deletes a signature, initials, or stamps image. 832 833 This method makes a synchronous HTTP request by default. To make an 834 asynchronous HTTP request, please define a `callback` function 835 to be invoked when receiving the response. 836 >>> def callback_function(response): 837 >>> pprint(response) 838 >>> 839 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 840 841 :param callback function: The callback function 842 for asynchronous request. (optional) 843 :param str account_id: The external account number (int) or account ID Guid. (required) 844 :param str image_type: One of **signature_image** or **initials_image**. (required) 845 :param str signature_id: The ID of the signature being accessed. (required) 846 :return: AccountSignature 847 If the method is called asynchronously, 848 returns the request thread. 849 """ 850 851 all_params = ['account_id', 'image_type', 'signature_id'] 852 all_params.append('callback') 853 all_params.append('_return_http_data_only') 854 all_params.append('_preload_content') 855 all_params.append('_request_timeout') 856 857 params = locals() 858 for key, val in iteritems(params['kwargs']): 859 if key not in all_params: 860 raise TypeError( 861 "Got an unexpected keyword argument '%s'" 862 " to method delete_account_signature_image" % key 863 ) 864 params[key] = val 865 del params['kwargs'] 866 # verify the required parameter 'account_id' is set 867 if ('account_id' not in params) or (params['account_id'] is None): 868 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 869 # verify the required parameter 'image_type' is set 870 if ('image_type' not in params) or (params['image_type'] is None): 871 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 872 # verify the required parameter 'signature_id' is set 873 if ('signature_id' not in params) or (params['signature_id'] is None): 874 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 875 876 877 collection_formats = {} 878 879 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 880 path_params = {} 881 if 'account_id' in params: 882 path_params['accountId'] = params['account_id'] 883 if 'image_type' in params: 884 path_params['imageType'] = params['image_type'] 885 if 'signature_id' in params: 886 path_params['signatureId'] = params['signature_id'] 887 888 query_params = {} 889 890 header_params = {} 891 892 form_params = [] 893 local_var_files = {} 894 895 body_params = None 896 # HTTP header `Accept` 897 header_params['Accept'] = self.api_client.\ 898 select_header_accept(['application/json']) 899 900 # Authentication setting 901 auth_settings = [] 902 903 return self.api_client.call_api(resource_path, 'DELETE', 904 path_params, 905 query_params, 906 header_params, 907 body=body_params, 908 post_params=form_params, 909 files=local_var_files, 910 response_type='AccountSignature', 911 auth_settings=auth_settings, 912 callback=params.get('callback'), 913 _return_http_data_only=params.get('_return_http_data_only'), 914 _preload_content=params.get('_preload_content', True), 915 _request_timeout=params.get('_request_timeout'), 916 collection_formats=collection_formats) 917 918 def delete_brand(self, account_id, brand_id, **kwargs): 919 """ 920 Removes a brand. 921 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 922 This method makes a synchronous HTTP request by default. To make an 923 asynchronous HTTP request, please define a `callback` function 924 to be invoked when receiving the response. 925 >>> def callback_function(response): 926 >>> pprint(response) 927 >>> 928 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 929 930 :param callback function: The callback function 931 for asynchronous request. (optional) 932 :param str account_id: The external account number (int) or account ID Guid. (required) 933 :param str brand_id: The unique identifier of a brand. (required) 934 :return: None 935 If the method is called asynchronously, 936 returns the request thread. 937 """ 938 kwargs['_return_http_data_only'] = True 939 if kwargs.get('callback'): 940 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 941 else: 942 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 943 return data 944 945 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 946 """ 947 Removes a brand. 948 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 949 This method makes a synchronous HTTP request by default. To make an 950 asynchronous HTTP request, please define a `callback` function 951 to be invoked when receiving the response. 952 >>> def callback_function(response): 953 >>> pprint(response) 954 >>> 955 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 956 957 :param callback function: The callback function 958 for asynchronous request. (optional) 959 :param str account_id: The external account number (int) or account ID Guid. (required) 960 :param str brand_id: The unique identifier of a brand. (required) 961 :return: None 962 If the method is called asynchronously, 963 returns the request thread. 964 """ 965 966 all_params = ['account_id', 'brand_id'] 967 all_params.append('callback') 968 all_params.append('_return_http_data_only') 969 all_params.append('_preload_content') 970 all_params.append('_request_timeout') 971 972 params = locals() 973 for key, val in iteritems(params['kwargs']): 974 if key not in all_params: 975 raise TypeError( 976 "Got an unexpected keyword argument '%s'" 977 " to method delete_brand" % key 978 ) 979 params[key] = val 980 del params['kwargs'] 981 # verify the required parameter 'account_id' is set 982 if ('account_id' not in params) or (params['account_id'] is None): 983 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 984 # verify the required parameter 'brand_id' is set 985 if ('brand_id' not in params) or (params['brand_id'] is None): 986 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 987 988 989 collection_formats = {} 990 991 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 992 path_params = {} 993 if 'account_id' in params: 994 path_params['accountId'] = params['account_id'] 995 if 'brand_id' in params: 996 path_params['brandId'] = params['brand_id'] 997 998 query_params = {} 999 1000 header_params = {} 1001 1002 form_params = [] 1003 local_var_files = {} 1004 1005 body_params = None 1006 # HTTP header `Accept` 1007 header_params['Accept'] = self.api_client.\ 1008 select_header_accept(['application/json']) 1009 1010 # Authentication setting 1011 auth_settings = [] 1012 1013 return self.api_client.call_api(resource_path, 'DELETE', 1014 path_params, 1015 query_params, 1016 header_params, 1017 body=body_params, 1018 post_params=form_params, 1019 files=local_var_files, 1020 response_type=None, 1021 auth_settings=auth_settings, 1022 callback=params.get('callback'), 1023 _return_http_data_only=params.get('_return_http_data_only'), 1024 _preload_content=params.get('_preload_content', True), 1025 _request_timeout=params.get('_request_timeout'), 1026 collection_formats=collection_formats) 1027 1028 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1029 """ 1030 Delete one branding logo. 1031 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1032 This method makes a synchronous HTTP request by default. To make an 1033 asynchronous HTTP request, please define a `callback` function 1034 to be invoked when receiving the response. 1035 >>> def callback_function(response): 1036 >>> pprint(response) 1037 >>> 1038 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1039 1040 :param callback function: The callback function 1041 for asynchronous request. (optional) 1042 :param str account_id: The external account number (int) or account ID Guid. (required) 1043 :param str brand_id: The unique identifier of a brand. (required) 1044 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1045 :return: None 1046 If the method is called asynchronously, 1047 returns the request thread. 1048 """ 1049 kwargs['_return_http_data_only'] = True 1050 if kwargs.get('callback'): 1051 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1052 else: 1053 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1054 return data 1055 1056 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1057 """ 1058 Delete one branding logo. 1059 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1060 This method makes a synchronous HTTP request by default. To make an 1061 asynchronous HTTP request, please define a `callback` function 1062 to be invoked when receiving the response. 1063 >>> def callback_function(response): 1064 >>> pprint(response) 1065 >>> 1066 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1067 1068 :param callback function: The callback function 1069 for asynchronous request. (optional) 1070 :param str account_id: The external account number (int) or account ID Guid. (required) 1071 :param str brand_id: The unique identifier of a brand. (required) 1072 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1073 :return: None 1074 If the method is called asynchronously, 1075 returns the request thread. 1076 """ 1077 1078 all_params = ['account_id', 'brand_id', 'logo_type'] 1079 all_params.append('callback') 1080 all_params.append('_return_http_data_only') 1081 all_params.append('_preload_content') 1082 all_params.append('_request_timeout') 1083 1084 params = locals() 1085 for key, val in iteritems(params['kwargs']): 1086 if key not in all_params: 1087 raise TypeError( 1088 "Got an unexpected keyword argument '%s'" 1089 " to method delete_brand_logo_by_type" % key 1090 ) 1091 params[key] = val 1092 del params['kwargs'] 1093 # verify the required parameter 'account_id' is set 1094 if ('account_id' not in params) or (params['account_id'] is None): 1095 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1096 # verify the required parameter 'brand_id' is set 1097 if ('brand_id' not in params) or (params['brand_id'] is None): 1098 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1099 # verify the required parameter 'logo_type' is set 1100 if ('logo_type' not in params) or (params['logo_type'] is None): 1101 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1102 1103 1104 collection_formats = {} 1105 1106 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1107 path_params = {} 1108 if 'account_id' in params: 1109 path_params['accountId'] = params['account_id'] 1110 if 'brand_id' in params: 1111 path_params['brandId'] = params['brand_id'] 1112 if 'logo_type' in params: 1113 path_params['logoType'] = params['logo_type'] 1114 1115 query_params = {} 1116 1117 header_params = {} 1118 1119 form_params = [] 1120 local_var_files = {} 1121 1122 body_params = None 1123 # HTTP header `Accept` 1124 header_params['Accept'] = self.api_client.\ 1125 select_header_accept(['application/json']) 1126 1127 # Authentication setting 1128 auth_settings = [] 1129 1130 return self.api_client.call_api(resource_path, 'DELETE', 1131 path_params, 1132 query_params, 1133 header_params, 1134 body=body_params, 1135 post_params=form_params, 1136 files=local_var_files, 1137 response_type=None, 1138 auth_settings=auth_settings, 1139 callback=params.get('callback'), 1140 _return_http_data_only=params.get('_return_http_data_only'), 1141 _preload_content=params.get('_preload_content', True), 1142 _request_timeout=params.get('_request_timeout'), 1143 collection_formats=collection_formats) 1144 1145 def delete_brands(self, account_id, **kwargs): 1146 """ 1147 Deletes one or more brand profiles. 1148 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1149 This method makes a synchronous HTTP request by default. To make an 1150 asynchronous HTTP request, please define a `callback` function 1151 to be invoked when receiving the response. 1152 >>> def callback_function(response): 1153 >>> pprint(response) 1154 >>> 1155 >>> thread = api.delete_brands(account_id, callback=callback_function) 1156 1157 :param callback function: The callback function 1158 for asynchronous request. (optional) 1159 :param str account_id: The external account number (int) or account ID Guid. (required) 1160 :param BrandsRequest brands_request: 1161 :return: BrandsResponse 1162 If the method is called asynchronously, 1163 returns the request thread. 1164 """ 1165 kwargs['_return_http_data_only'] = True 1166 if kwargs.get('callback'): 1167 return self.delete_brands_with_http_info(account_id, **kwargs) 1168 else: 1169 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1170 return data 1171 1172 def delete_brands_with_http_info(self, account_id, **kwargs): 1173 """ 1174 Deletes one or more brand profiles. 1175 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1176 This method makes a synchronous HTTP request by default. To make an 1177 asynchronous HTTP request, please define a `callback` function 1178 to be invoked when receiving the response. 1179 >>> def callback_function(response): 1180 >>> pprint(response) 1181 >>> 1182 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1183 1184 :param callback function: The callback function 1185 for asynchronous request. (optional) 1186 :param str account_id: The external account number (int) or account ID Guid. (required) 1187 :param BrandsRequest brands_request: 1188 :return: BrandsResponse 1189 If the method is called asynchronously, 1190 returns the request thread. 1191 """ 1192 1193 all_params = ['account_id', 'brands_request'] 1194 all_params.append('callback') 1195 all_params.append('_return_http_data_only') 1196 all_params.append('_preload_content') 1197 all_params.append('_request_timeout') 1198 1199 params = locals() 1200 for key, val in iteritems(params['kwargs']): 1201 if key not in all_params: 1202 raise TypeError( 1203 "Got an unexpected keyword argument '%s'" 1204 " to method delete_brands" % key 1205 ) 1206 params[key] = val 1207 del params['kwargs'] 1208 # verify the required parameter 'account_id' is set 1209 if ('account_id' not in params) or (params['account_id'] is None): 1210 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1211 1212 1213 collection_formats = {} 1214 1215 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1216 path_params = {} 1217 if 'account_id' in params: 1218 path_params['accountId'] = params['account_id'] 1219 1220 query_params = {} 1221 1222 header_params = {} 1223 1224 form_params = [] 1225 local_var_files = {} 1226 1227 body_params = None 1228 if 'brands_request' in params: 1229 body_params = params['brands_request'] 1230 # HTTP header `Accept` 1231 header_params['Accept'] = self.api_client.\ 1232 select_header_accept(['application/json']) 1233 1234 # Authentication setting 1235 auth_settings = [] 1236 1237 return self.api_client.call_api(resource_path, 'DELETE', 1238 path_params, 1239 query_params, 1240 header_params, 1241 body=body_params, 1242 post_params=form_params, 1243 files=local_var_files, 1244 response_type='BrandsResponse', 1245 auth_settings=auth_settings, 1246 callback=params.get('callback'), 1247 _return_http_data_only=params.get('_return_http_data_only'), 1248 _preload_content=params.get('_preload_content', True), 1249 _request_timeout=params.get('_request_timeout'), 1250 collection_formats=collection_formats) 1251 1252 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1253 """ 1254 Deletes the signature for one or more captive recipient records. 1255 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1256 This method makes a synchronous HTTP request by default. To make an 1257 asynchronous HTTP request, please define a `callback` function 1258 to be invoked when receiving the response. 1259 >>> def callback_function(response): 1260 >>> pprint(response) 1261 >>> 1262 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1263 1264 :param callback function: The callback function 1265 for asynchronous request. (optional) 1266 :param str account_id: The external account number (int) or account ID Guid. (required) 1267 :param str recipient_part: (required) 1268 :param CaptiveRecipientInformation captive_recipient_information: 1269 :return: CaptiveRecipientInformation 1270 If the method is called asynchronously, 1271 returns the request thread. 1272 """ 1273 kwargs['_return_http_data_only'] = True 1274 if kwargs.get('callback'): 1275 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1276 else: 1277 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1278 return data 1279 1280 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1281 """ 1282 Deletes the signature for one or more captive recipient records. 1283 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1284 This method makes a synchronous HTTP request by default. To make an 1285 asynchronous HTTP request, please define a `callback` function 1286 to be invoked when receiving the response. 1287 >>> def callback_function(response): 1288 >>> pprint(response) 1289 >>> 1290 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1291 1292 :param callback function: The callback function 1293 for asynchronous request. (optional) 1294 :param str account_id: The external account number (int) or account ID Guid. (required) 1295 :param str recipient_part: (required) 1296 :param CaptiveRecipientInformation captive_recipient_information: 1297 :return: CaptiveRecipientInformation 1298 If the method is called asynchronously, 1299 returns the request thread. 1300 """ 1301 1302 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1303 all_params.append('callback') 1304 all_params.append('_return_http_data_only') 1305 all_params.append('_preload_content') 1306 all_params.append('_request_timeout') 1307 1308 params = locals() 1309 for key, val in iteritems(params['kwargs']): 1310 if key not in all_params: 1311 raise TypeError( 1312 "Got an unexpected keyword argument '%s'" 1313 " to method delete_captive_recipient" % key 1314 ) 1315 params[key] = val 1316 del params['kwargs'] 1317 # verify the required parameter 'account_id' is set 1318 if ('account_id' not in params) or (params['account_id'] is None): 1319 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1320 # verify the required parameter 'recipient_part' is set 1321 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1322 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1323 1324 1325 collection_formats = {} 1326 1327 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1328 path_params = {} 1329 if 'account_id' in params: 1330 path_params['accountId'] = params['account_id'] 1331 if 'recipient_part' in params: 1332 path_params['recipientPart'] = params['recipient_part'] 1333 1334 query_params = {} 1335 1336 header_params = {} 1337 1338 form_params = [] 1339 local_var_files = {} 1340 1341 body_params = None 1342 if 'captive_recipient_information' in params: 1343 body_params = params['captive_recipient_information'] 1344 # HTTP header `Accept` 1345 header_params['Accept'] = self.api_client.\ 1346 select_header_accept(['application/json']) 1347 1348 # Authentication setting 1349 auth_settings = [] 1350 1351 return self.api_client.call_api(resource_path, 'DELETE', 1352 path_params, 1353 query_params, 1354 header_params, 1355 body=body_params, 1356 post_params=form_params, 1357 files=local_var_files, 1358 response_type='CaptiveRecipientInformation', 1359 auth_settings=auth_settings, 1360 callback=params.get('callback'), 1361 _return_http_data_only=params.get('_return_http_data_only'), 1362 _preload_content=params.get('_preload_content', True), 1363 _request_timeout=params.get('_request_timeout'), 1364 collection_formats=collection_formats) 1365 1366 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1367 """ 1368 Delete an existing account custom field. 1369 This method deletes an existing account custom field. 1370 This method makes a synchronous HTTP request by default. To make an 1371 asynchronous HTTP request, please define a `callback` function 1372 to be invoked when receiving the response. 1373 >>> def callback_function(response): 1374 >>> pprint(response) 1375 >>> 1376 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1377 1378 :param callback function: The callback function 1379 for asynchronous request. (optional) 1380 :param str account_id: The external account number (int) or account ID Guid. (required) 1381 :param str custom_field_id: (required) 1382 :param str apply_to_templates: 1383 :return: None 1384 If the method is called asynchronously, 1385 returns the request thread. 1386 """ 1387 kwargs['_return_http_data_only'] = True 1388 if kwargs.get('callback'): 1389 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1390 else: 1391 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1392 return data 1393 1394 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1395 """ 1396 Delete an existing account custom field. 1397 This method deletes an existing account custom field. 1398 This method makes a synchronous HTTP request by default. To make an 1399 asynchronous HTTP request, please define a `callback` function 1400 to be invoked when receiving the response. 1401 >>> def callback_function(response): 1402 >>> pprint(response) 1403 >>> 1404 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1405 1406 :param callback function: The callback function 1407 for asynchronous request. (optional) 1408 :param str account_id: The external account number (int) or account ID Guid. (required) 1409 :param str custom_field_id: (required) 1410 :param str apply_to_templates: 1411 :return: None 1412 If the method is called asynchronously, 1413 returns the request thread. 1414 """ 1415 1416 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1417 all_params.append('callback') 1418 all_params.append('_return_http_data_only') 1419 all_params.append('_preload_content') 1420 all_params.append('_request_timeout') 1421 1422 params = locals() 1423 for key, val in iteritems(params['kwargs']): 1424 if key not in all_params: 1425 raise TypeError( 1426 "Got an unexpected keyword argument '%s'" 1427 " to method delete_custom_field" % key 1428 ) 1429 params[key] = val 1430 del params['kwargs'] 1431 # verify the required parameter 'account_id' is set 1432 if ('account_id' not in params) or (params['account_id'] is None): 1433 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1434 # verify the required parameter 'custom_field_id' is set 1435 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1436 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1437 1438 1439 collection_formats = {} 1440 1441 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1442 path_params = {} 1443 if 'account_id' in params: 1444 path_params['accountId'] = params['account_id'] 1445 if 'custom_field_id' in params: 1446 path_params['customFieldId'] = params['custom_field_id'] 1447 1448 query_params = {} 1449 if 'apply_to_templates' in params: 1450 query_params['apply_to_templates'] = params['apply_to_templates'] 1451 1452 header_params = {} 1453 1454 form_params = [] 1455 local_var_files = {} 1456 1457 body_params = None 1458 # HTTP header `Accept` 1459 header_params['Accept'] = self.api_client.\ 1460 select_header_accept(['application/json']) 1461 1462 # Authentication setting 1463 auth_settings = [] 1464 1465 return self.api_client.call_api(resource_path, 'DELETE', 1466 path_params, 1467 query_params, 1468 header_params, 1469 body=body_params, 1470 post_params=form_params, 1471 files=local_var_files, 1472 response_type=None, 1473 auth_settings=auth_settings, 1474 callback=params.get('callback'), 1475 _return_http_data_only=params.get('_return_http_data_only'), 1476 _preload_content=params.get('_preload_content', True), 1477 _request_timeout=params.get('_request_timeout'), 1478 collection_formats=collection_formats) 1479 1480 def delete_e_note_configuration(self, account_id, **kwargs): 1481 """ 1482 Deletes configuration information for the eNote eOriginal integration. 1483 1484 This method makes a synchronous HTTP request by default. To make an 1485 asynchronous HTTP request, please define a `callback` function 1486 to be invoked when receiving the response. 1487 >>> def callback_function(response): 1488 >>> pprint(response) 1489 >>> 1490 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1491 1492 :param callback function: The callback function 1493 for asynchronous request. (optional) 1494 :param str account_id: The external account number (int) or account ID Guid. (required) 1495 :return: None 1496 If the method is called asynchronously, 1497 returns the request thread. 1498 """ 1499 kwargs['_return_http_data_only'] = True 1500 if kwargs.get('callback'): 1501 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1502 else: 1503 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1504 return data 1505 1506 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1507 """ 1508 Deletes configuration information for the eNote eOriginal integration. 1509 1510 This method makes a synchronous HTTP request by default. To make an 1511 asynchronous HTTP request, please define a `callback` function 1512 to be invoked when receiving the response. 1513 >>> def callback_function(response): 1514 >>> pprint(response) 1515 >>> 1516 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1517 1518 :param callback function: The callback function 1519 for asynchronous request. (optional) 1520 :param str account_id: The external account number (int) or account ID Guid. (required) 1521 :return: None 1522 If the method is called asynchronously, 1523 returns the request thread. 1524 """ 1525 1526 all_params = ['account_id'] 1527 all_params.append('callback') 1528 all_params.append('_return_http_data_only') 1529 all_params.append('_preload_content') 1530 all_params.append('_request_timeout') 1531 1532 params = locals() 1533 for key, val in iteritems(params['kwargs']): 1534 if key not in all_params: 1535 raise TypeError( 1536 "Got an unexpected keyword argument '%s'" 1537 " to method delete_e_note_configuration" % key 1538 ) 1539 params[key] = val 1540 del params['kwargs'] 1541 # verify the required parameter 'account_id' is set 1542 if ('account_id' not in params) or (params['account_id'] is None): 1543 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1544 1545 1546 collection_formats = {} 1547 1548 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1549 path_params = {} 1550 if 'account_id' in params: 1551 path_params['accountId'] = params['account_id'] 1552 1553 query_params = {} 1554 1555 header_params = {} 1556 1557 form_params = [] 1558 local_var_files = {} 1559 1560 body_params = None 1561 # HTTP header `Accept` 1562 header_params['Accept'] = self.api_client.\ 1563 select_header_accept(['application/json']) 1564 1565 # Authentication setting 1566 auth_settings = [] 1567 1568 return self.api_client.call_api(resource_path, 'DELETE', 1569 path_params, 1570 query_params, 1571 header_params, 1572 body=body_params, 1573 post_params=form_params, 1574 files=local_var_files, 1575 response_type=None, 1576 auth_settings=auth_settings, 1577 callback=params.get('callback'), 1578 _return_http_data_only=params.get('_return_http_data_only'), 1579 _preload_content=params.get('_preload_content', True), 1580 _request_timeout=params.get('_request_timeout'), 1581 collection_formats=collection_formats) 1582 1583 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1584 """ 1585 Deletes a permissions profile within the specified account. 1586 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1587 This method makes a synchronous HTTP request by default. To make an 1588 asynchronous HTTP request, please define a `callback` function 1589 to be invoked when receiving the response. 1590 >>> def callback_function(response): 1591 >>> pprint(response) 1592 >>> 1593 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1594 1595 :param callback function: The callback function 1596 for asynchronous request. (optional) 1597 :param str account_id: The external account number (int) or account ID Guid. (required) 1598 :param str permission_profile_id: (required) 1599 :param str move_users_to: 1600 :return: None 1601 If the method is called asynchronously, 1602 returns the request thread. 1603 """ 1604 kwargs['_return_http_data_only'] = True 1605 if kwargs.get('callback'): 1606 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1607 else: 1608 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1609 return data 1610 1611 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1612 """ 1613 Deletes a permissions profile within the specified account. 1614 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1615 This method makes a synchronous HTTP request by default. To make an 1616 asynchronous HTTP request, please define a `callback` function 1617 to be invoked when receiving the response. 1618 >>> def callback_function(response): 1619 >>> pprint(response) 1620 >>> 1621 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1622 1623 :param callback function: The callback function 1624 for asynchronous request. (optional) 1625 :param str account_id: The external account number (int) or account ID Guid. (required) 1626 :param str permission_profile_id: (required) 1627 :param str move_users_to: 1628 :return: None 1629 If the method is called asynchronously, 1630 returns the request thread. 1631 """ 1632 1633 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1634 all_params.append('callback') 1635 all_params.append('_return_http_data_only') 1636 all_params.append('_preload_content') 1637 all_params.append('_request_timeout') 1638 1639 params = locals() 1640 for key, val in iteritems(params['kwargs']): 1641 if key not in all_params: 1642 raise TypeError( 1643 "Got an unexpected keyword argument '%s'" 1644 " to method delete_permission_profile" % key 1645 ) 1646 params[key] = val 1647 del params['kwargs'] 1648 # verify the required parameter 'account_id' is set 1649 if ('account_id' not in params) or (params['account_id'] is None): 1650 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1651 # verify the required parameter 'permission_profile_id' is set 1652 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1653 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1654 1655 1656 collection_formats = {} 1657 1658 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1659 path_params = {} 1660 if 'account_id' in params: 1661 path_params['accountId'] = params['account_id'] 1662 if 'permission_profile_id' in params: 1663 path_params['permissionProfileId'] = params['permission_profile_id'] 1664 1665 query_params = {} 1666 if 'move_users_to' in params: 1667 query_params['move_users_to'] = params['move_users_to'] 1668 1669 header_params = {} 1670 1671 form_params = [] 1672 local_var_files = {} 1673 1674 body_params = None 1675 # HTTP header `Accept` 1676 header_params['Accept'] = self.api_client.\ 1677 select_header_accept(['application/json']) 1678 1679 # Authentication setting 1680 auth_settings = [] 1681 1682 return self.api_client.call_api(resource_path, 'DELETE', 1683 path_params, 1684 query_params, 1685 header_params, 1686 body=body_params, 1687 post_params=form_params, 1688 files=local_var_files, 1689 response_type=None, 1690 auth_settings=auth_settings, 1691 callback=params.get('callback'), 1692 _return_http_data_only=params.get('_return_http_data_only'), 1693 _preload_content=params.get('_preload_content', True), 1694 _request_timeout=params.get('_request_timeout'), 1695 collection_formats=collection_formats) 1696 1697 def get_account_identity_verification(self, account_id, **kwargs): 1698 """ 1699 Get the list of identity verification options for an account 1700 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 1701 This method makes a synchronous HTTP request by default. To make an 1702 asynchronous HTTP request, please define a `callback` function 1703 to be invoked when receiving the response. 1704 >>> def callback_function(response): 1705 >>> pprint(response) 1706 >>> 1707 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 1708 1709 :param callback function: The callback function 1710 for asynchronous request. (optional) 1711 :param str account_id: The external account number (int) or account ID Guid. (required) 1712 :return: AccountIdentityVerificationResponse 1713 If the method is called asynchronously, 1714 returns the request thread. 1715 """ 1716 kwargs['_return_http_data_only'] = True 1717 if kwargs.get('callback'): 1718 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 1719 else: 1720 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 1721 return data 1722 1723 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 1724 """ 1725 Get the list of identity verification options for an account 1726 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 1727 This method makes a synchronous HTTP request by default. To make an 1728 asynchronous HTTP request, please define a `callback` function 1729 to be invoked when receiving the response. 1730 >>> def callback_function(response): 1731 >>> pprint(response) 1732 >>> 1733 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 1734 1735 :param callback function: The callback function 1736 for asynchronous request. (optional) 1737 :param str account_id: The external account number (int) or account ID Guid. (required) 1738 :return: AccountIdentityVerificationResponse 1739 If the method is called asynchronously, 1740 returns the request thread. 1741 """ 1742 1743 all_params = ['account_id'] 1744 all_params.append('callback') 1745 all_params.append('_return_http_data_only') 1746 all_params.append('_preload_content') 1747 all_params.append('_request_timeout') 1748 1749 params = locals() 1750 for key, val in iteritems(params['kwargs']): 1751 if key not in all_params: 1752 raise TypeError( 1753 "Got an unexpected keyword argument '%s'" 1754 " to method get_account_identity_verification" % key 1755 ) 1756 params[key] = val 1757 del params['kwargs'] 1758 # verify the required parameter 'account_id' is set 1759 if ('account_id' not in params) or (params['account_id'] is None): 1760 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 1761 1762 1763 collection_formats = {} 1764 1765 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 1766 path_params = {} 1767 if 'account_id' in params: 1768 path_params['accountId'] = params['account_id'] 1769 1770 query_params = {} 1771 1772 header_params = {} 1773 1774 form_params = [] 1775 local_var_files = {} 1776 1777 body_params = None 1778 # HTTP header `Accept` 1779 header_params['Accept'] = self.api_client.\ 1780 select_header_accept(['application/json']) 1781 1782 # Authentication setting 1783 auth_settings = [] 1784 1785 return self.api_client.call_api(resource_path, 'GET', 1786 path_params, 1787 query_params, 1788 header_params, 1789 body=body_params, 1790 post_params=form_params, 1791 files=local_var_files, 1792 response_type='AccountIdentityVerificationResponse', 1793 auth_settings=auth_settings, 1794 callback=params.get('callback'), 1795 _return_http_data_only=params.get('_return_http_data_only'), 1796 _preload_content=params.get('_preload_content', True), 1797 _request_timeout=params.get('_request_timeout'), 1798 collection_formats=collection_formats) 1799 1800 def get_account_information(self, account_id, **kwargs): 1801 """ 1802 Retrieves the account information for the specified account. 1803 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 1804 This method makes a synchronous HTTP request by default. To make an 1805 asynchronous HTTP request, please define a `callback` function 1806 to be invoked when receiving the response. 1807 >>> def callback_function(response): 1808 >>> pprint(response) 1809 >>> 1810 >>> thread = api.get_account_information(account_id, callback=callback_function) 1811 1812 :param callback function: The callback function 1813 for asynchronous request. (optional) 1814 :param str account_id: The external account number (int) or account ID Guid. (required) 1815 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 1816 :return: AccountInformation 1817 If the method is called asynchronously, 1818 returns the request thread. 1819 """ 1820 kwargs['_return_http_data_only'] = True 1821 if kwargs.get('callback'): 1822 return self.get_account_information_with_http_info(account_id, **kwargs) 1823 else: 1824 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 1825 return data 1826 1827 def get_account_information_with_http_info(self, account_id, **kwargs): 1828 """ 1829 Retrieves the account information for the specified account. 1830 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 1831 This method makes a synchronous HTTP request by default. To make an 1832 asynchronous HTTP request, please define a `callback` function 1833 to be invoked when receiving the response. 1834 >>> def callback_function(response): 1835 >>> pprint(response) 1836 >>> 1837 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 1838 1839 :param callback function: The callback function 1840 for asynchronous request. (optional) 1841 :param str account_id: The external account number (int) or account ID Guid. (required) 1842 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 1843 :return: AccountInformation 1844 If the method is called asynchronously, 1845 returns the request thread. 1846 """ 1847 1848 all_params = ['account_id', 'include_account_settings'] 1849 all_params.append('callback') 1850 all_params.append('_return_http_data_only') 1851 all_params.append('_preload_content') 1852 all_params.append('_request_timeout') 1853 1854 params = locals() 1855 for key, val in iteritems(params['kwargs']): 1856 if key not in all_params: 1857 raise TypeError( 1858 "Got an unexpected keyword argument '%s'" 1859 " to method get_account_information" % key 1860 ) 1861 params[key] = val 1862 del params['kwargs'] 1863 # verify the required parameter 'account_id' is set 1864 if ('account_id' not in params) or (params['account_id'] is None): 1865 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 1866 1867 1868 collection_formats = {} 1869 1870 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 1871 path_params = {} 1872 if 'account_id' in params: 1873 path_params['accountId'] = params['account_id'] 1874 1875 query_params = {} 1876 if 'include_account_settings' in params: 1877 query_params['include_account_settings'] = params['include_account_settings'] 1878 1879 header_params = {} 1880 1881 form_params = [] 1882 local_var_files = {} 1883 1884 body_params = None 1885 # HTTP header `Accept` 1886 header_params['Accept'] = self.api_client.\ 1887 select_header_accept(['application/json']) 1888 1889 # Authentication setting 1890 auth_settings = [] 1891 1892 return self.api_client.call_api(resource_path, 'GET', 1893 path_params, 1894 query_params, 1895 header_params, 1896 body=body_params, 1897 post_params=form_params, 1898 files=local_var_files, 1899 response_type='AccountInformation', 1900 auth_settings=auth_settings, 1901 callback=params.get('callback'), 1902 _return_http_data_only=params.get('_return_http_data_only'), 1903 _preload_content=params.get('_preload_content', True), 1904 _request_timeout=params.get('_request_timeout'), 1905 collection_formats=collection_formats) 1906 1907 def get_account_signature(self, account_id, signature_id, **kwargs): 1908 """ 1909 Returns information about a single signature by specifed signatureId. 1910 1911 This method makes a synchronous HTTP request by default. To make an 1912 asynchronous HTTP request, please define a `callback` function 1913 to be invoked when receiving the response. 1914 >>> def callback_function(response): 1915 >>> pprint(response) 1916 >>> 1917 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 1918 1919 :param callback function: The callback function 1920 for asynchronous request. (optional) 1921 :param str account_id: The external account number (int) or account ID Guid. (required) 1922 :param str signature_id: The ID of the signature being accessed. (required) 1923 :return: AccountSignature 1924 If the method is called asynchronously, 1925 returns the request thread. 1926 """ 1927 kwargs['_return_http_data_only'] = True 1928 if kwargs.get('callback'): 1929 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 1930 else: 1931 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 1932 return data 1933 1934 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 1935 """ 1936 Returns information about a single signature by specifed signatureId. 1937 1938 This method makes a synchronous HTTP request by default. To make an 1939 asynchronous HTTP request, please define a `callback` function 1940 to be invoked when receiving the response. 1941 >>> def callback_function(response): 1942 >>> pprint(response) 1943 >>> 1944 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 1945 1946 :param callback function: The callback function 1947 for asynchronous request. (optional) 1948 :param str account_id: The external account number (int) or account ID Guid. (required) 1949 :param str signature_id: The ID of the signature being accessed. (required) 1950 :return: AccountSignature 1951 If the method is called asynchronously, 1952 returns the request thread. 1953 """ 1954 1955 all_params = ['account_id', 'signature_id'] 1956 all_params.append('callback') 1957 all_params.append('_return_http_data_only') 1958 all_params.append('_preload_content') 1959 all_params.append('_request_timeout') 1960 1961 params = locals() 1962 for key, val in iteritems(params['kwargs']): 1963 if key not in all_params: 1964 raise TypeError( 1965 "Got an unexpected keyword argument '%s'" 1966 " to method get_account_signature" % key 1967 ) 1968 params[key] = val 1969 del params['kwargs'] 1970 # verify the required parameter 'account_id' is set 1971 if ('account_id' not in params) or (params['account_id'] is None): 1972 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 1973 # verify the required parameter 'signature_id' is set 1974 if ('signature_id' not in params) or (params['signature_id'] is None): 1975 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 1976 1977 1978 collection_formats = {} 1979 1980 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 1981 path_params = {} 1982 if 'account_id' in params: 1983 path_params['accountId'] = params['account_id'] 1984 if 'signature_id' in params: 1985 path_params['signatureId'] = params['signature_id'] 1986 1987 query_params = {} 1988 1989 header_params = {} 1990 1991 form_params = [] 1992 local_var_files = {} 1993 1994 body_params = None 1995 # HTTP header `Accept` 1996 header_params['Accept'] = self.api_client.\ 1997 select_header_accept(['application/json']) 1998 1999 # Authentication setting 2000 auth_settings = [] 2001 2002 return self.api_client.call_api(resource_path, 'GET', 2003 path_params, 2004 query_params, 2005 header_params, 2006 body=body_params, 2007 post_params=form_params, 2008 files=local_var_files, 2009 response_type='AccountSignature', 2010 auth_settings=auth_settings, 2011 callback=params.get('callback'), 2012 _return_http_data_only=params.get('_return_http_data_only'), 2013 _preload_content=params.get('_preload_content', True), 2014 _request_timeout=params.get('_request_timeout'), 2015 collection_formats=collection_formats) 2016 2017 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2018 """ 2019 Returns a signature, initials, or stamps image. 2020 2021 This method makes a synchronous HTTP request by default. To make an 2022 asynchronous HTTP request, please define a `callback` function 2023 to be invoked when receiving the response. 2024 >>> def callback_function(response): 2025 >>> pprint(response) 2026 >>> 2027 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2028 2029 :param callback function: The callback function 2030 for asynchronous request. (optional) 2031 :param str account_id: The external account number (int) or account ID Guid. (required) 2032 :param str image_type: One of **signature_image** or **initials_image**. (required) 2033 :param str signature_id: The ID of the signature being accessed. (required) 2034 :param str include_chrome: 2035 :return: file 2036 If the method is called asynchronously, 2037 returns the request thread. 2038 """ 2039 kwargs['_return_http_data_only'] = True 2040 if kwargs.get('callback'): 2041 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2042 else: 2043 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2044 return data 2045 2046 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2047 """ 2048 Returns a signature, initials, or stamps image. 2049 2050 This method makes a synchronous HTTP request by default. To make an 2051 asynchronous HTTP request, please define a `callback` function 2052 to be invoked when receiving the response. 2053 >>> def callback_function(response): 2054 >>> pprint(response) 2055 >>> 2056 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2057 2058 :param callback function: The callback function 2059 for asynchronous request. (optional) 2060 :param str account_id: The external account number (int) or account ID Guid. (required) 2061 :param str image_type: One of **signature_image** or **initials_image**. (required) 2062 :param str signature_id: The ID of the signature being accessed. (required) 2063 :param str include_chrome: 2064 :return: file 2065 If the method is called asynchronously, 2066 returns the request thread. 2067 """ 2068 2069 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2070 all_params.append('callback') 2071 all_params.append('_return_http_data_only') 2072 all_params.append('_preload_content') 2073 all_params.append('_request_timeout') 2074 2075 params = locals() 2076 for key, val in iteritems(params['kwargs']): 2077 if key not in all_params: 2078 raise TypeError( 2079 "Got an unexpected keyword argument '%s'" 2080 " to method get_account_signature_image" % key 2081 ) 2082 params[key] = val 2083 del params['kwargs'] 2084 # verify the required parameter 'account_id' is set 2085 if ('account_id' not in params) or (params['account_id'] is None): 2086 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2087 # verify the required parameter 'image_type' is set 2088 if ('image_type' not in params) or (params['image_type'] is None): 2089 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2090 # verify the required parameter 'signature_id' is set 2091 if ('signature_id' not in params) or (params['signature_id'] is None): 2092 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2093 2094 2095 collection_formats = {} 2096 2097 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2098 path_params = {} 2099 if 'account_id' in params: 2100 path_params['accountId'] = params['account_id'] 2101 if 'image_type' in params: 2102 path_params['imageType'] = params['image_type'] 2103 if 'signature_id' in params: 2104 path_params['signatureId'] = params['signature_id'] 2105 2106 query_params = {} 2107 if 'include_chrome' in params: 2108 query_params['include_chrome'] = params['include_chrome'] 2109 2110 header_params = {} 2111 2112 form_params = [] 2113 local_var_files = {} 2114 2115 body_params = None 2116 # HTTP header `Accept` 2117 header_params['Accept'] = self.api_client.\ 2118 select_header_accept(['image/gif']) 2119 2120 # Authentication setting 2121 auth_settings = [] 2122 2123 return self.api_client.call_api(resource_path, 'GET', 2124 path_params, 2125 query_params, 2126 header_params, 2127 body=body_params, 2128 post_params=form_params, 2129 files=local_var_files, 2130 response_type='file', 2131 auth_settings=auth_settings, 2132 callback=params.get('callback'), 2133 _return_http_data_only=params.get('_return_http_data_only'), 2134 _preload_content=params.get('_preload_content', True), 2135 _request_timeout=params.get('_request_timeout'), 2136 collection_formats=collection_formats) 2137 2138 def get_account_signatures(self, account_id, **kwargs): 2139 """ 2140 Returns the managed signature definitions for the account 2141 2142 This method makes a synchronous HTTP request by default. To make an 2143 asynchronous HTTP request, please define a `callback` function 2144 to be invoked when receiving the response. 2145 >>> def callback_function(response): 2146 >>> pprint(response) 2147 >>> 2148 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2149 2150 :param callback function: The callback function 2151 for asynchronous request. (optional) 2152 :param str account_id: The external account number (int) or account ID Guid. (required) 2153 :param str stamp_format: 2154 :param str stamp_name: 2155 :param str stamp_type: 2156 :return: AccountSignaturesInformation 2157 If the method is called asynchronously, 2158 returns the request thread. 2159 """ 2160 kwargs['_return_http_data_only'] = True 2161 if kwargs.get('callback'): 2162 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2163 else: 2164 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2165 return data 2166 2167 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2168 """ 2169 Returns the managed signature definitions for the account 2170 2171 This method makes a synchronous HTTP request by default. To make an 2172 asynchronous HTTP request, please define a `callback` function 2173 to be invoked when receiving the response. 2174 >>> def callback_function(response): 2175 >>> pprint(response) 2176 >>> 2177 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2178 2179 :param callback function: The callback function 2180 for asynchronous request. (optional) 2181 :param str account_id: The external account number (int) or account ID Guid. (required) 2182 :param str stamp_format: 2183 :param str stamp_name: 2184 :param str stamp_type: 2185 :return: AccountSignaturesInformation 2186 If the method is called asynchronously, 2187 returns the request thread. 2188 """ 2189 2190 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2191 all_params.append('callback') 2192 all_params.append('_return_http_data_only') 2193 all_params.append('_preload_content') 2194 all_params.append('_request_timeout') 2195 2196 params = locals() 2197 for key, val in iteritems(params['kwargs']): 2198 if key not in all_params: 2199 raise TypeError( 2200 "Got an unexpected keyword argument '%s'" 2201 " to method get_account_signatures" % key 2202 ) 2203 params[key] = val 2204 del params['kwargs'] 2205 # verify the required parameter 'account_id' is set 2206 if ('account_id' not in params) or (params['account_id'] is None): 2207 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2208 2209 2210 collection_formats = {} 2211 2212 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2213 path_params = {} 2214 if 'account_id' in params: 2215 path_params['accountId'] = params['account_id'] 2216 2217 query_params = {} 2218 if 'stamp_format' in params: 2219 query_params['stamp_format'] = params['stamp_format'] 2220 if 'stamp_name' in params: 2221 query_params['stamp_name'] = params['stamp_name'] 2222 if 'stamp_type' in params: 2223 query_params['stamp_type'] = params['stamp_type'] 2224 2225 header_params = {} 2226 2227 form_params = [] 2228 local_var_files = {} 2229 2230 body_params = None 2231 # HTTP header `Accept` 2232 header_params['Accept'] = self.api_client.\ 2233 select_header_accept(['application/json']) 2234 2235 # Authentication setting 2236 auth_settings = [] 2237 2238 return self.api_client.call_api(resource_path, 'GET', 2239 path_params, 2240 query_params, 2241 header_params, 2242 body=body_params, 2243 post_params=form_params, 2244 files=local_var_files, 2245 response_type='AccountSignaturesInformation', 2246 auth_settings=auth_settings, 2247 callback=params.get('callback'), 2248 _return_http_data_only=params.get('_return_http_data_only'), 2249 _preload_content=params.get('_preload_content', True), 2250 _request_timeout=params.get('_request_timeout'), 2251 collection_formats=collection_formats) 2252 2253 def get_account_tab_settings(self, account_id, **kwargs): 2254 """ 2255 Returns tab settings list for specified account 2256 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2257 This method makes a synchronous HTTP request by default. To make an 2258 asynchronous HTTP request, please define a `callback` function 2259 to be invoked when receiving the response. 2260 >>> def callback_function(response): 2261 >>> pprint(response) 2262 >>> 2263 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2264 2265 :param callback function: The callback function 2266 for asynchronous request. (optional) 2267 :param str account_id: The external account number (int) or account ID Guid. (required) 2268 :return: TabAccountSettings 2269 If the method is called asynchronously, 2270 returns the request thread. 2271 """ 2272 kwargs['_return_http_data_only'] = True 2273 if kwargs.get('callback'): 2274 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2275 else: 2276 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2277 return data 2278 2279 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2280 """ 2281 Returns tab settings list for specified account 2282 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2283 This method makes a synchronous HTTP request by default. To make an 2284 asynchronous HTTP request, please define a `callback` function 2285 to be invoked when receiving the response. 2286 >>> def callback_function(response): 2287 >>> pprint(response) 2288 >>> 2289 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2290 2291 :param callback function: The callback function 2292 for asynchronous request. (optional) 2293 :param str account_id: The external account number (int) or account ID Guid. (required) 2294 :return: TabAccountSettings 2295 If the method is called asynchronously, 2296 returns the request thread. 2297 """ 2298 2299 all_params = ['account_id'] 2300 all_params.append('callback') 2301 all_params.append('_return_http_data_only') 2302 all_params.append('_preload_content') 2303 all_params.append('_request_timeout') 2304 2305 params = locals() 2306 for key, val in iteritems(params['kwargs']): 2307 if key not in all_params: 2308 raise TypeError( 2309 "Got an unexpected keyword argument '%s'" 2310 " to method get_account_tab_settings" % key 2311 ) 2312 params[key] = val 2313 del params['kwargs'] 2314 # verify the required parameter 'account_id' is set 2315 if ('account_id' not in params) or (params['account_id'] is None): 2316 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2317 2318 2319 collection_formats = {} 2320 2321 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2322 path_params = {} 2323 if 'account_id' in params: 2324 path_params['accountId'] = params['account_id'] 2325 2326 query_params = {} 2327 2328 header_params = {} 2329 2330 form_params = [] 2331 local_var_files = {} 2332 2333 body_params = None 2334 # HTTP header `Accept` 2335 header_params['Accept'] = self.api_client.\ 2336 select_header_accept(['application/json']) 2337 2338 # Authentication setting 2339 auth_settings = [] 2340 2341 return self.api_client.call_api(resource_path, 'GET', 2342 path_params, 2343 query_params, 2344 header_params, 2345 body=body_params, 2346 post_params=form_params, 2347 files=local_var_files, 2348 response_type='TabAccountSettings', 2349 auth_settings=auth_settings, 2350 callback=params.get('callback'), 2351 _return_http_data_only=params.get('_return_http_data_only'), 2352 _preload_content=params.get('_preload_content', True), 2353 _request_timeout=params.get('_request_timeout'), 2354 collection_formats=collection_formats) 2355 2356 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2357 """ 2358 Get all payment gateway account for the provided accountId 2359 This method returns a list of payment gateway accounts and basic information about them. 2360 This method makes a synchronous HTTP request by default. To make an 2361 asynchronous HTTP request, please define a `callback` function 2362 to be invoked when receiving the response. 2363 >>> def callback_function(response): 2364 >>> pprint(response) 2365 >>> 2366 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2367 2368 :param callback function: The callback function 2369 for asynchronous request. (optional) 2370 :param str account_id: The external account number (int) or account ID Guid. (required) 2371 :return: PaymentGatewayAccountsInfo 2372 If the method is called asynchronously, 2373 returns the request thread. 2374 """ 2375 kwargs['_return_http_data_only'] = True 2376 if kwargs.get('callback'): 2377 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2378 else: 2379 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2380 return data 2381 2382 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2383 """ 2384 Get all payment gateway account for the provided accountId 2385 This method returns a list of payment gateway accounts and basic information about them. 2386 This method makes a synchronous HTTP request by default. To make an 2387 asynchronous HTTP request, please define a `callback` function 2388 to be invoked when receiving the response. 2389 >>> def callback_function(response): 2390 >>> pprint(response) 2391 >>> 2392 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2393 2394 :param callback function: The callback function 2395 for asynchronous request. (optional) 2396 :param str account_id: The external account number (int) or account ID Guid. (required) 2397 :return: PaymentGatewayAccountsInfo 2398 If the method is called asynchronously, 2399 returns the request thread. 2400 """ 2401 2402 all_params = ['account_id'] 2403 all_params.append('callback') 2404 all_params.append('_return_http_data_only') 2405 all_params.append('_preload_content') 2406 all_params.append('_request_timeout') 2407 2408 params = locals() 2409 for key, val in iteritems(params['kwargs']): 2410 if key not in all_params: 2411 raise TypeError( 2412 "Got an unexpected keyword argument '%s'" 2413 " to method get_all_payment_gateway_accounts" % key 2414 ) 2415 params[key] = val 2416 del params['kwargs'] 2417 # verify the required parameter 'account_id' is set 2418 if ('account_id' not in params) or (params['account_id'] is None): 2419 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 2420 2421 2422 collection_formats = {} 2423 2424 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 2425 path_params = {} 2426 if 'account_id' in params: 2427 path_params['accountId'] = params['account_id'] 2428 2429 query_params = {} 2430 2431 header_params = {} 2432 2433 form_params = [] 2434 local_var_files = {} 2435 2436 body_params = None 2437 # HTTP header `Accept` 2438 header_params['Accept'] = self.api_client.\ 2439 select_header_accept(['application/json']) 2440 2441 # Authentication setting 2442 auth_settings = [] 2443 2444 return self.api_client.call_api(resource_path, 'GET', 2445 path_params, 2446 query_params, 2447 header_params, 2448 body=body_params, 2449 post_params=form_params, 2450 files=local_var_files, 2451 response_type='PaymentGatewayAccountsInfo', 2452 auth_settings=auth_settings, 2453 callback=params.get('callback'), 2454 _return_http_data_only=params.get('_return_http_data_only'), 2455 _preload_content=params.get('_preload_content', True), 2456 _request_timeout=params.get('_request_timeout'), 2457 collection_formats=collection_formats) 2458 2459 def get_billing_charges(self, account_id, **kwargs): 2460 """ 2461 Gets list of recurring and usage charges for the account. 2462 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 2463 This method makes a synchronous HTTP request by default. To make an 2464 asynchronous HTTP request, please define a `callback` function 2465 to be invoked when receiving the response. 2466 >>> def callback_function(response): 2467 >>> pprint(response) 2468 >>> 2469 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 2470 2471 :param callback function: The callback function 2472 for asynchronous request. (optional) 2473 :param str account_id: The external account number (int) or account ID Guid. (required) 2474 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 2475 :return: BillingChargeResponse 2476 If the method is called asynchronously, 2477 returns the request thread. 2478 """ 2479 kwargs['_return_http_data_only'] = True 2480 if kwargs.get('callback'): 2481 return self.get_billing_charges_with_http_info(account_id, **kwargs) 2482 else: 2483 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 2484 return data 2485 2486 def get_billing_charges_with_http_info(self, account_id, **kwargs): 2487 """ 2488 Gets list of recurring and usage charges for the account. 2489 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 2490 This method makes a synchronous HTTP request by default. To make an 2491 asynchronous HTTP request, please define a `callback` function 2492 to be invoked when receiving the response. 2493 >>> def callback_function(response): 2494 >>> pprint(response) 2495 >>> 2496 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 2497 2498 :param callback function: The callback function 2499 for asynchronous request. (optional) 2500 :param str account_id: The external account number (int) or account ID Guid. (required) 2501 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 2502 :return: BillingChargeResponse 2503 If the method is called asynchronously, 2504 returns the request thread. 2505 """ 2506 2507 all_params = ['account_id', 'include_charges'] 2508 all_params.append('callback') 2509 all_params.append('_return_http_data_only') 2510 all_params.append('_preload_content') 2511 all_params.append('_request_timeout') 2512 2513 params = locals() 2514 for key, val in iteritems(params['kwargs']): 2515 if key not in all_params: 2516 raise TypeError( 2517 "Got an unexpected keyword argument '%s'" 2518 " to method get_billing_charges" % key 2519 ) 2520 params[key] = val 2521 del params['kwargs'] 2522 # verify the required parameter 'account_id' is set 2523 if ('account_id' not in params) or (params['account_id'] is None): 2524 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 2525 2526 2527 collection_formats = {} 2528 2529 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 2530 path_params = {} 2531 if 'account_id' in params: 2532 path_params['accountId'] = params['account_id'] 2533 2534 query_params = {} 2535 if 'include_charges' in params: 2536 query_params['include_charges'] = params['include_charges'] 2537 2538 header_params = {} 2539 2540 form_params = [] 2541 local_var_files = {} 2542 2543 body_params = None 2544 # HTTP header `Accept` 2545 header_params['Accept'] = self.api_client.\ 2546 select_header_accept(['application/json']) 2547 2548 # Authentication setting 2549 auth_settings = [] 2550 2551 return self.api_client.call_api(resource_path, 'GET', 2552 path_params, 2553 query_params, 2554 header_params, 2555 body=body_params, 2556 post_params=form_params, 2557 files=local_var_files, 2558 response_type='BillingChargeResponse', 2559 auth_settings=auth_settings, 2560 callback=params.get('callback'), 2561 _return_http_data_only=params.get('_return_http_data_only'), 2562 _preload_content=params.get('_preload_content', True), 2563 _request_timeout=params.get('_request_timeout'), 2564 collection_formats=collection_formats) 2565 2566 def get_brand(self, account_id, brand_id, **kwargs): 2567 """ 2568 Get information for a specific brand. 2569 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2570 This method makes a synchronous HTTP request by default. To make an 2571 asynchronous HTTP request, please define a `callback` function 2572 to be invoked when receiving the response. 2573 >>> def callback_function(response): 2574 >>> pprint(response) 2575 >>> 2576 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 2577 2578 :param callback function: The callback function 2579 for asynchronous request. (optional) 2580 :param str account_id: The external account number (int) or account ID Guid. (required) 2581 :param str brand_id: The unique identifier of a brand. (required) 2582 :param str include_external_references: 2583 :param str include_logos: 2584 :return: Brand 2585 If the method is called asynchronously, 2586 returns the request thread. 2587 """ 2588 kwargs['_return_http_data_only'] = True 2589 if kwargs.get('callback'): 2590 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 2591 else: 2592 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 2593 return data 2594 2595 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 2596 """ 2597 Get information for a specific brand. 2598 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2599 This method makes a synchronous HTTP request by default. To make an 2600 asynchronous HTTP request, please define a `callback` function 2601 to be invoked when receiving the response. 2602 >>> def callback_function(response): 2603 >>> pprint(response) 2604 >>> 2605 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 2606 2607 :param callback function: The callback function 2608 for asynchronous request. (optional) 2609 :param str account_id: The external account number (int) or account ID Guid. (required) 2610 :param str brand_id: The unique identifier of a brand. (required) 2611 :param str include_external_references: 2612 :param str include_logos: 2613 :return: Brand 2614 If the method is called asynchronously, 2615 returns the request thread. 2616 """ 2617 2618 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 2619 all_params.append('callback') 2620 all_params.append('_return_http_data_only') 2621 all_params.append('_preload_content') 2622 all_params.append('_request_timeout') 2623 2624 params = locals() 2625 for key, val in iteritems(params['kwargs']): 2626 if key not in all_params: 2627 raise TypeError( 2628 "Got an unexpected keyword argument '%s'" 2629 " to method get_brand" % key 2630 ) 2631 params[key] = val 2632 del params['kwargs'] 2633 # verify the required parameter 'account_id' is set 2634 if ('account_id' not in params) or (params['account_id'] is None): 2635 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 2636 # verify the required parameter 'brand_id' is set 2637 if ('brand_id' not in params) or (params['brand_id'] is None): 2638 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 2639 2640 2641 collection_formats = {} 2642 2643 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 2644 path_params = {} 2645 if 'account_id' in params: 2646 path_params['accountId'] = params['account_id'] 2647 if 'brand_id' in params: 2648 path_params['brandId'] = params['brand_id'] 2649 2650 query_params = {} 2651 if 'include_external_references' in params: 2652 query_params['include_external_references'] = params['include_external_references'] 2653 if 'include_logos' in params: 2654 query_params['include_logos'] = params['include_logos'] 2655 2656 header_params = {} 2657 2658 form_params = [] 2659 local_var_files = {} 2660 2661 body_params = None 2662 # HTTP header `Accept` 2663 header_params['Accept'] = self.api_client.\ 2664 select_header_accept(['application/json']) 2665 2666 # Authentication setting 2667 auth_settings = [] 2668 2669 return self.api_client.call_api(resource_path, 'GET', 2670 path_params, 2671 query_params, 2672 header_params, 2673 body=body_params, 2674 post_params=form_params, 2675 files=local_var_files, 2676 response_type='Brand', 2677 auth_settings=auth_settings, 2678 callback=params.get('callback'), 2679 _return_http_data_only=params.get('_return_http_data_only'), 2680 _preload_content=params.get('_preload_content', True), 2681 _request_timeout=params.get('_request_timeout'), 2682 collection_formats=collection_formats) 2683 2684 def get_brand_export_file(self, account_id, brand_id, **kwargs): 2685 """ 2686 Export a specific brand. 2687 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2688 This method makes a synchronous HTTP request by default. To make an 2689 asynchronous HTTP request, please define a `callback` function 2690 to be invoked when receiving the response. 2691 >>> def callback_function(response): 2692 >>> pprint(response) 2693 >>> 2694 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 2695 2696 :param callback function: The callback function 2697 for asynchronous request. (optional) 2698 :param str account_id: The external account number (int) or account ID Guid. (required) 2699 :param str brand_id: The unique identifier of a brand. (required) 2700 :return: None 2701 If the method is called asynchronously, 2702 returns the request thread. 2703 """ 2704 kwargs['_return_http_data_only'] = True 2705 if kwargs.get('callback'): 2706 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 2707 else: 2708 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 2709 return data 2710 2711 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 2712 """ 2713 Export a specific brand. 2714 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2715 This method makes a synchronous HTTP request by default. To make an 2716 asynchronous HTTP request, please define a `callback` function 2717 to be invoked when receiving the response. 2718 >>> def callback_function(response): 2719 >>> pprint(response) 2720 >>> 2721 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 2722 2723 :param callback function: The callback function 2724 for asynchronous request. (optional) 2725 :param str account_id: The external account number (int) or account ID Guid. (required) 2726 :param str brand_id: The unique identifier of a brand. (required) 2727 :return: None 2728 If the method is called asynchronously, 2729 returns the request thread. 2730 """ 2731 2732 all_params = ['account_id', 'brand_id'] 2733 all_params.append('callback') 2734 all_params.append('_return_http_data_only') 2735 all_params.append('_preload_content') 2736 all_params.append('_request_timeout') 2737 2738 params = locals() 2739 for key, val in iteritems(params['kwargs']): 2740 if key not in all_params: 2741 raise TypeError( 2742 "Got an unexpected keyword argument '%s'" 2743 " to method get_brand_export_file" % key 2744 ) 2745 params[key] = val 2746 del params['kwargs'] 2747 # verify the required parameter 'account_id' is set 2748 if ('account_id' not in params) or (params['account_id'] is None): 2749 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 2750 # verify the required parameter 'brand_id' is set 2751 if ('brand_id' not in params) or (params['brand_id'] is None): 2752 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 2753 2754 2755 collection_formats = {} 2756 2757 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 2758 path_params = {} 2759 if 'account_id' in params: 2760 path_params['accountId'] = params['account_id'] 2761 if 'brand_id' in params: 2762 path_params['brandId'] = params['brand_id'] 2763 2764 query_params = {} 2765 2766 header_params = {} 2767 2768 form_params = [] 2769 local_var_files = {} 2770 2771 body_params = None 2772 # HTTP header `Accept` 2773 header_params['Accept'] = self.api_client.\ 2774 select_header_accept(['application/json']) 2775 2776 # Authentication setting 2777 auth_settings = [] 2778 2779 return self.api_client.call_api(resource_path, 'GET', 2780 path_params, 2781 query_params, 2782 header_params, 2783 body=body_params, 2784 post_params=form_params, 2785 files=local_var_files, 2786 response_type=None, 2787 auth_settings=auth_settings, 2788 callback=params.get('callback'), 2789 _return_http_data_only=params.get('_return_http_data_only'), 2790 _preload_content=params.get('_preload_content', True), 2791 _request_timeout=params.get('_request_timeout'), 2792 collection_formats=collection_formats) 2793 2794 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 2795 """ 2796 Obtains the specified image for a brand. 2797 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2798 This method makes a synchronous HTTP request by default. To make an 2799 asynchronous HTTP request, please define a `callback` function 2800 to be invoked when receiving the response. 2801 >>> def callback_function(response): 2802 >>> pprint(response) 2803 >>> 2804 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 2805 2806 :param callback function: The callback function 2807 for asynchronous request. (optional) 2808 :param str account_id: The external account number (int) or account ID Guid. (required) 2809 :param str brand_id: The unique identifier of a brand. (required) 2810 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 2811 :return: file 2812 If the method is called asynchronously, 2813 returns the request thread. 2814 """ 2815 kwargs['_return_http_data_only'] = True 2816 if kwargs.get('callback'): 2817 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 2818 else: 2819 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 2820 return data 2821 2822 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 2823 """ 2824 Obtains the specified image for a brand. 2825 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2826 This method makes a synchronous HTTP request by default. To make an 2827 asynchronous HTTP request, please define a `callback` function 2828 to be invoked when receiving the response. 2829 >>> def callback_function(response): 2830 >>> pprint(response) 2831 >>> 2832 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 2833 2834 :param callback function: The callback function 2835 for asynchronous request. (optional) 2836 :param str account_id: The external account number (int) or account ID Guid. (required) 2837 :param str brand_id: The unique identifier of a brand. (required) 2838 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 2839 :return: file 2840 If the method is called asynchronously, 2841 returns the request thread. 2842 """ 2843 2844 all_params = ['account_id', 'brand_id', 'logo_type'] 2845 all_params.append('callback') 2846 all_params.append('_return_http_data_only') 2847 all_params.append('_preload_content') 2848 all_params.append('_request_timeout') 2849 2850 params = locals() 2851 for key, val in iteritems(params['kwargs']): 2852 if key not in all_params: 2853 raise TypeError( 2854 "Got an unexpected keyword argument '%s'" 2855 " to method get_brand_logo_by_type" % key 2856 ) 2857 params[key] = val 2858 del params['kwargs'] 2859 # verify the required parameter 'account_id' is set 2860 if ('account_id' not in params) or (params['account_id'] is None): 2861 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 2862 # verify the required parameter 'brand_id' is set 2863 if ('brand_id' not in params) or (params['brand_id'] is None): 2864 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 2865 # verify the required parameter 'logo_type' is set 2866 if ('logo_type' not in params) or (params['logo_type'] is None): 2867 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 2868 2869 2870 collection_formats = {} 2871 2872 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 2873 path_params = {} 2874 if 'account_id' in params: 2875 path_params['accountId'] = params['account_id'] 2876 if 'brand_id' in params: 2877 path_params['brandId'] = params['brand_id'] 2878 if 'logo_type' in params: 2879 path_params['logoType'] = params['logo_type'] 2880 2881 query_params = {} 2882 2883 header_params = {} 2884 2885 form_params = [] 2886 local_var_files = {} 2887 2888 body_params = None 2889 # HTTP header `Accept` 2890 header_params['Accept'] = self.api_client.\ 2891 select_header_accept(['image/png']) 2892 2893 # Authentication setting 2894 auth_settings = [] 2895 2896 return self.api_client.call_api(resource_path, 'GET', 2897 path_params, 2898 query_params, 2899 header_params, 2900 body=body_params, 2901 post_params=form_params, 2902 files=local_var_files, 2903 response_type='file', 2904 auth_settings=auth_settings, 2905 callback=params.get('callback'), 2906 _return_http_data_only=params.get('_return_http_data_only'), 2907 _preload_content=params.get('_preload_content', True), 2908 _request_timeout=params.get('_request_timeout'), 2909 collection_formats=collection_formats) 2910 2911 def get_brand_resources(self, account_id, brand_id, **kwargs): 2912 """ 2913 Returns the specified account's list of branding resources (metadata). 2914 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2915 This method makes a synchronous HTTP request by default. To make an 2916 asynchronous HTTP request, please define a `callback` function 2917 to be invoked when receiving the response. 2918 >>> def callback_function(response): 2919 >>> pprint(response) 2920 >>> 2921 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 2922 2923 :param callback function: The callback function 2924 for asynchronous request. (optional) 2925 :param str account_id: The external account number (int) or account ID Guid. (required) 2926 :param str brand_id: The unique identifier of a brand. (required) 2927 :return: BrandResourcesList 2928 If the method is called asynchronously, 2929 returns the request thread. 2930 """ 2931 kwargs['_return_http_data_only'] = True 2932 if kwargs.get('callback'): 2933 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 2934 else: 2935 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 2936 return data 2937 2938 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 2939 """ 2940 Returns the specified account's list of branding resources (metadata). 2941 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2942 This method makes a synchronous HTTP request by default. To make an 2943 asynchronous HTTP request, please define a `callback` function 2944 to be invoked when receiving the response. 2945 >>> def callback_function(response): 2946 >>> pprint(response) 2947 >>> 2948 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 2949 2950 :param callback function: The callback function 2951 for asynchronous request. (optional) 2952 :param str account_id: The external account number (int) or account ID Guid. (required) 2953 :param str brand_id: The unique identifier of a brand. (required) 2954 :return: BrandResourcesList 2955 If the method is called asynchronously, 2956 returns the request thread. 2957 """ 2958 2959 all_params = ['account_id', 'brand_id'] 2960 all_params.append('callback') 2961 all_params.append('_return_http_data_only') 2962 all_params.append('_preload_content') 2963 all_params.append('_request_timeout') 2964 2965 params = locals() 2966 for key, val in iteritems(params['kwargs']): 2967 if key not in all_params: 2968 raise TypeError( 2969 "Got an unexpected keyword argument '%s'" 2970 " to method get_brand_resources" % key 2971 ) 2972 params[key] = val 2973 del params['kwargs'] 2974 # verify the required parameter 'account_id' is set 2975 if ('account_id' not in params) or (params['account_id'] is None): 2976 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 2977 # verify the required parameter 'brand_id' is set 2978 if ('brand_id' not in params) or (params['brand_id'] is None): 2979 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 2980 2981 2982 collection_formats = {} 2983 2984 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 2985 path_params = {} 2986 if 'account_id' in params: 2987 path_params['accountId'] = params['account_id'] 2988 if 'brand_id' in params: 2989 path_params['brandId'] = params['brand_id'] 2990 2991 query_params = {} 2992 2993 header_params = {} 2994 2995 form_params = [] 2996 local_var_files = {} 2997 2998 body_params = None 2999 # HTTP header `Accept` 3000 header_params['Accept'] = self.api_client.\ 3001 select_header_accept(['application/json']) 3002 3003 # Authentication setting 3004 auth_settings = [] 3005 3006 return self.api_client.call_api(resource_path, 'GET', 3007 path_params, 3008 query_params, 3009 header_params, 3010 body=body_params, 3011 post_params=form_params, 3012 files=local_var_files, 3013 response_type='BrandResourcesList', 3014 auth_settings=auth_settings, 3015 callback=params.get('callback'), 3016 _return_http_data_only=params.get('_return_http_data_only'), 3017 _preload_content=params.get('_preload_content', True), 3018 _request_timeout=params.get('_request_timeout'), 3019 collection_formats=collection_formats) 3020 3021 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3022 """ 3023 Returns the specified branding resource file. 3024 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3025 This method makes a synchronous HTTP request by default. To make an 3026 asynchronous HTTP request, please define a `callback` function 3027 to be invoked when receiving the response. 3028 >>> def callback_function(response): 3029 >>> pprint(response) 3030 >>> 3031 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3032 3033 :param callback function: The callback function 3034 for asynchronous request. (optional) 3035 :param str account_id: The external account number (int) or account ID Guid. (required) 3036 :param str brand_id: The unique identifier of a brand. (required) 3037 :param str resource_content_type: (required) 3038 :param str langcode: 3039 :param str return_master: 3040 :return: None 3041 If the method is called asynchronously, 3042 returns the request thread. 3043 """ 3044 kwargs['_return_http_data_only'] = True 3045 if kwargs.get('callback'): 3046 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3047 else: 3048 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3049 return data 3050 3051 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3052 """ 3053 Returns the specified branding resource file. 3054 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3055 This method makes a synchronous HTTP request by default. To make an 3056 asynchronous HTTP request, please define a `callback` function 3057 to be invoked when receiving the response. 3058 >>> def callback_function(response): 3059 >>> pprint(response) 3060 >>> 3061 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3062 3063 :param callback function: The callback function 3064 for asynchronous request. (optional) 3065 :param str account_id: The external account number (int) or account ID Guid. (required) 3066 :param str brand_id: The unique identifier of a brand. (required) 3067 :param str resource_content_type: (required) 3068 :param str langcode: 3069 :param str return_master: 3070 :return: None 3071 If the method is called asynchronously, 3072 returns the request thread. 3073 """ 3074 3075 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3076 all_params.append('callback') 3077 all_params.append('_return_http_data_only') 3078 all_params.append('_preload_content') 3079 all_params.append('_request_timeout') 3080 3081 params = locals() 3082 for key, val in iteritems(params['kwargs']): 3083 if key not in all_params: 3084 raise TypeError( 3085 "Got an unexpected keyword argument '%s'" 3086 " to method get_brand_resources_by_content_type" % key 3087 ) 3088 params[key] = val 3089 del params['kwargs'] 3090 # verify the required parameter 'account_id' is set 3091 if ('account_id' not in params) or (params['account_id'] is None): 3092 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3093 # verify the required parameter 'brand_id' is set 3094 if ('brand_id' not in params) or (params['brand_id'] is None): 3095 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3096 # verify the required parameter 'resource_content_type' is set 3097 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3098 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3099 3100 3101 collection_formats = {} 3102 3103 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3104 path_params = {} 3105 if 'account_id' in params: 3106 path_params['accountId'] = params['account_id'] 3107 if 'brand_id' in params: 3108 path_params['brandId'] = params['brand_id'] 3109 if 'resource_content_type' in params: 3110 path_params['resourceContentType'] = params['resource_content_type'] 3111 3112 query_params = {} 3113 if 'langcode' in params: 3114 query_params['langcode'] = params['langcode'] 3115 if 'return_master' in params: 3116 query_params['return_master'] = params['return_master'] 3117 3118 header_params = {} 3119 3120 form_params = [] 3121 local_var_files = {} 3122 3123 body_params = None 3124 # HTTP header `Accept` 3125 header_params['Accept'] = self.api_client.\ 3126 select_header_accept(['application/json']) 3127 3128 # Authentication setting 3129 auth_settings = [] 3130 3131 return self.api_client.call_api(resource_path, 'GET', 3132 path_params, 3133 query_params, 3134 header_params, 3135 body=body_params, 3136 post_params=form_params, 3137 files=local_var_files, 3138 response_type=None, 3139 auth_settings=auth_settings, 3140 callback=params.get('callback'), 3141 _return_http_data_only=params.get('_return_http_data_only'), 3142 _preload_content=params.get('_preload_content', True), 3143 _request_timeout=params.get('_request_timeout'), 3144 collection_formats=collection_formats) 3145 3146 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3147 """ 3148 Gets the Electronic Record and Signature Disclosure. 3149 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3150 This method makes a synchronous HTTP request by default. To make an 3151 asynchronous HTTP request, please define a `callback` function 3152 to be invoked when receiving the response. 3153 >>> def callback_function(response): 3154 >>> pprint(response) 3155 >>> 3156 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3157 3158 :param callback function: The callback function 3159 for asynchronous request. (optional) 3160 :param str account_id: The external account number (int) or account ID Guid. (required) 3161 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3162 :return: ConsumerDisclosure 3163 If the method is called asynchronously, 3164 returns the request thread. 3165 """ 3166 kwargs['_return_http_data_only'] = True 3167 if kwargs.get('callback'): 3168 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3169 else: 3170 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3171 return data 3172 3173 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3174 """ 3175 Gets the Electronic Record and Signature Disclosure. 3176 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3177 This method makes a synchronous HTTP request by default. To make an 3178 asynchronous HTTP request, please define a `callback` function 3179 to be invoked when receiving the response. 3180 >>> def callback_function(response): 3181 >>> pprint(response) 3182 >>> 3183 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3184 3185 :param callback function: The callback function 3186 for asynchronous request. (optional) 3187 :param str account_id: The external account number (int) or account ID Guid. (required) 3188 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3189 :return: ConsumerDisclosure 3190 If the method is called asynchronously, 3191 returns the request thread. 3192 """ 3193 3194 all_params = ['account_id', 'lang_code'] 3195 all_params.append('callback') 3196 all_params.append('_return_http_data_only') 3197 all_params.append('_preload_content') 3198 all_params.append('_request_timeout') 3199 3200 params = locals() 3201 for key, val in iteritems(params['kwargs']): 3202 if key not in all_params: 3203 raise TypeError( 3204 "Got an unexpected keyword argument '%s'" 3205 " to method get_consumer_disclosure" % key 3206 ) 3207 params[key] = val 3208 del params['kwargs'] 3209 # verify the required parameter 'account_id' is set 3210 if ('account_id' not in params) or (params['account_id'] is None): 3211 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3212 # verify the required parameter 'lang_code' is set 3213 if ('lang_code' not in params) or (params['lang_code'] is None): 3214 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3215 3216 3217 collection_formats = {} 3218 3219 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3220 path_params = {} 3221 if 'account_id' in params: 3222 path_params['accountId'] = params['account_id'] 3223 if 'lang_code' in params: 3224 path_params['langCode'] = params['lang_code'] 3225 3226 query_params = {} 3227 3228 header_params = {} 3229 3230 form_params = [] 3231 local_var_files = {} 3232 3233 body_params = None 3234 # HTTP header `Accept` 3235 header_params['Accept'] = self.api_client.\ 3236 select_header_accept(['application/json']) 3237 3238 # Authentication setting 3239 auth_settings = [] 3240 3241 return self.api_client.call_api(resource_path, 'GET', 3242 path_params, 3243 query_params, 3244 header_params, 3245 body=body_params, 3246 post_params=form_params, 3247 files=local_var_files, 3248 response_type='ConsumerDisclosure', 3249 auth_settings=auth_settings, 3250 callback=params.get('callback'), 3251 _return_http_data_only=params.get('_return_http_data_only'), 3252 _preload_content=params.get('_preload_content', True), 3253 _request_timeout=params.get('_request_timeout'), 3254 collection_formats=collection_formats) 3255 3256 def get_consumer_disclosure_default(self, account_id, **kwargs): 3257 """ 3258 Gets the Electronic Record and Signature Disclosure for the account. 3259 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 3260 This method makes a synchronous HTTP request by default. To make an 3261 asynchronous HTTP request, please define a `callback` function 3262 to be invoked when receiving the response. 3263 >>> def callback_function(response): 3264 >>> pprint(response) 3265 >>> 3266 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3267 3268 :param callback function: The callback function 3269 for asynchronous request. (optional) 3270 :param str account_id: The external account number (int) or account ID Guid. (required) 3271 :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 3272 :return: ConsumerDisclosure 3273 If the method is called asynchronously, 3274 returns the request thread. 3275 """ 3276 kwargs['_return_http_data_only'] = True 3277 if kwargs.get('callback'): 3278 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3279 else: 3280 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3281 return data 3282 3283 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3284 """ 3285 Gets the Electronic Record and Signature Disclosure for the account. 3286 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 3287 This method makes a synchronous HTTP request by default. To make an 3288 asynchronous HTTP request, please define a `callback` function 3289 to be invoked when receiving the response. 3290 >>> def callback_function(response): 3291 >>> pprint(response) 3292 >>> 3293 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3294 3295 :param callback function: The callback function 3296 for asynchronous request. (optional) 3297 :param str account_id: The external account number (int) or account ID Guid. (required) 3298 :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 3299 :return: ConsumerDisclosure 3300 If the method is called asynchronously, 3301 returns the request thread. 3302 """ 3303 3304 all_params = ['account_id', 'lang_code'] 3305 all_params.append('callback') 3306 all_params.append('_return_http_data_only') 3307 all_params.append('_preload_content') 3308 all_params.append('_request_timeout') 3309 3310 params = locals() 3311 for key, val in iteritems(params['kwargs']): 3312 if key not in all_params: 3313 raise TypeError( 3314 "Got an unexpected keyword argument '%s'" 3315 " to method get_consumer_disclosure_default" % key 3316 ) 3317 params[key] = val 3318 del params['kwargs'] 3319 # verify the required parameter 'account_id' is set 3320 if ('account_id' not in params) or (params['account_id'] is None): 3321 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3322 3323 3324 collection_formats = {} 3325 3326 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3327 path_params = {} 3328 if 'account_id' in params: 3329 path_params['accountId'] = params['account_id'] 3330 3331 query_params = {} 3332 if 'lang_code' in params: 3333 query_params['langCode'] = params['lang_code'] 3334 3335 header_params = {} 3336 3337 form_params = [] 3338 local_var_files = {} 3339 3340 body_params = None 3341 # HTTP header `Accept` 3342 header_params['Accept'] = self.api_client.\ 3343 select_header_accept(['application/json']) 3344 3345 # Authentication setting 3346 auth_settings = [] 3347 3348 return self.api_client.call_api(resource_path, 'GET', 3349 path_params, 3350 query_params, 3351 header_params, 3352 body=body_params, 3353 post_params=form_params, 3354 files=local_var_files, 3355 response_type='ConsumerDisclosure', 3356 auth_settings=auth_settings, 3357 callback=params.get('callback'), 3358 _return_http_data_only=params.get('_return_http_data_only'), 3359 _preload_content=params.get('_preload_content', True), 3360 _request_timeout=params.get('_request_timeout'), 3361 collection_formats=collection_formats) 3362 3363 def get_e_note_configuration(self, account_id, **kwargs): 3364 """ 3365 Returns the configuration information for the eNote eOriginal integration. 3366 3367 This method makes a synchronous HTTP request by default. To make an 3368 asynchronous HTTP request, please define a `callback` function 3369 to be invoked when receiving the response. 3370 >>> def callback_function(response): 3371 >>> pprint(response) 3372 >>> 3373 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3374 3375 :param callback function: The callback function 3376 for asynchronous request. (optional) 3377 :param str account_id: The external account number (int) or account ID Guid. (required) 3378 :return: ENoteConfiguration 3379 If the method is called asynchronously, 3380 returns the request thread. 3381 """ 3382 kwargs['_return_http_data_only'] = True 3383 if kwargs.get('callback'): 3384 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3385 else: 3386 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3387 return data 3388 3389 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3390 """ 3391 Returns the configuration information for the eNote eOriginal integration. 3392 3393 This method makes a synchronous HTTP request by default. To make an 3394 asynchronous HTTP request, please define a `callback` function 3395 to be invoked when receiving the response. 3396 >>> def callback_function(response): 3397 >>> pprint(response) 3398 >>> 3399 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3400 3401 :param callback function: The callback function 3402 for asynchronous request. (optional) 3403 :param str account_id: The external account number (int) or account ID Guid. (required) 3404 :return: ENoteConfiguration 3405 If the method is called asynchronously, 3406 returns the request thread. 3407 """ 3408 3409 all_params = ['account_id'] 3410 all_params.append('callback') 3411 all_params.append('_return_http_data_only') 3412 all_params.append('_preload_content') 3413 all_params.append('_request_timeout') 3414 3415 params = locals() 3416 for key, val in iteritems(params['kwargs']): 3417 if key not in all_params: 3418 raise TypeError( 3419 "Got an unexpected keyword argument '%s'" 3420 " to method get_e_note_configuration" % key 3421 ) 3422 params[key] = val 3423 del params['kwargs'] 3424 # verify the required parameter 'account_id' is set 3425 if ('account_id' not in params) or (params['account_id'] is None): 3426 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 3427 3428 3429 collection_formats = {} 3430 3431 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 3432 path_params = {} 3433 if 'account_id' in params: 3434 path_params['accountId'] = params['account_id'] 3435 3436 query_params = {} 3437 3438 header_params = {} 3439 3440 form_params = [] 3441 local_var_files = {} 3442 3443 body_params = None 3444 # HTTP header `Accept` 3445 header_params['Accept'] = self.api_client.\ 3446 select_header_accept(['application/json']) 3447 3448 # Authentication setting 3449 auth_settings = [] 3450 3451 return self.api_client.call_api(resource_path, 'GET', 3452 path_params, 3453 query_params, 3454 header_params, 3455 body=body_params, 3456 post_params=form_params, 3457 files=local_var_files, 3458 response_type='ENoteConfiguration', 3459 auth_settings=auth_settings, 3460 callback=params.get('callback'), 3461 _return_http_data_only=params.get('_return_http_data_only'), 3462 _preload_content=params.get('_preload_content', True), 3463 _request_timeout=params.get('_request_timeout'), 3464 collection_formats=collection_formats) 3465 3466 def get_envelope_purge_configuration(self, account_id, **kwargs): 3467 """ 3468 Select envelope purge configuration. 3469 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 3470 This method makes a synchronous HTTP request by default. To make an 3471 asynchronous HTTP request, please define a `callback` function 3472 to be invoked when receiving the response. 3473 >>> def callback_function(response): 3474 >>> pprint(response) 3475 >>> 3476 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 3477 3478 :param callback function: The callback function 3479 for asynchronous request. (optional) 3480 :param str account_id: The external account number (int) or account ID Guid. (required) 3481 :return: EnvelopePurgeConfiguration 3482 If the method is called asynchronously, 3483 returns the request thread. 3484 """ 3485 kwargs['_return_http_data_only'] = True 3486 if kwargs.get('callback'): 3487 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 3488 else: 3489 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 3490 return data 3491 3492 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 3493 """ 3494 Select envelope purge configuration. 3495 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 3496 This method makes a synchronous HTTP request by default. To make an 3497 asynchronous HTTP request, please define a `callback` function 3498 to be invoked when receiving the response. 3499 >>> def callback_function(response): 3500 >>> pprint(response) 3501 >>> 3502 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 3503 3504 :param callback function: The callback function 3505 for asynchronous request. (optional) 3506 :param str account_id: The external account number (int) or account ID Guid. (required) 3507 :return: EnvelopePurgeConfiguration 3508 If the method is called asynchronously, 3509 returns the request thread. 3510 """ 3511 3512 all_params = ['account_id'] 3513 all_params.append('callback') 3514 all_params.append('_return_http_data_only') 3515 all_params.append('_preload_content') 3516 all_params.append('_request_timeout') 3517 3518 params = locals() 3519 for key, val in iteritems(params['kwargs']): 3520 if key not in all_params: 3521 raise TypeError( 3522 "Got an unexpected keyword argument '%s'" 3523 " to method get_envelope_purge_configuration" % key 3524 ) 3525 params[key] = val 3526 del params['kwargs'] 3527 # verify the required parameter 'account_id' is set 3528 if ('account_id' not in params) or (params['account_id'] is None): 3529 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 3530 3531 3532 collection_formats = {} 3533 3534 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 3535 path_params = {} 3536 if 'account_id' in params: 3537 path_params['accountId'] = params['account_id'] 3538 3539 query_params = {} 3540 3541 header_params = {} 3542 3543 form_params = [] 3544 local_var_files = {} 3545 3546 body_params = None 3547 # HTTP header `Accept` 3548 header_params['Accept'] = self.api_client.\ 3549 select_header_accept(['application/json']) 3550 3551 # Authentication setting 3552 auth_settings = [] 3553 3554 return self.api_client.call_api(resource_path, 'GET', 3555 path_params, 3556 query_params, 3557 header_params, 3558 body=body_params, 3559 post_params=form_params, 3560 files=local_var_files, 3561 response_type='EnvelopePurgeConfiguration', 3562 auth_settings=auth_settings, 3563 callback=params.get('callback'), 3564 _return_http_data_only=params.get('_return_http_data_only'), 3565 _preload_content=params.get('_preload_content', True), 3566 _request_timeout=params.get('_request_timeout'), 3567 collection_formats=collection_formats) 3568 3569 def get_favorite_templates(self, account_id, **kwargs): 3570 """ 3571 Retrieves the list of favorited templates for this caller 3572 3573 This method makes a synchronous HTTP request by default. To make an 3574 asynchronous HTTP request, please define a `callback` function 3575 to be invoked when receiving the response. 3576 >>> def callback_function(response): 3577 >>> pprint(response) 3578 >>> 3579 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 3580 3581 :param callback function: The callback function 3582 for asynchronous request. (optional) 3583 :param str account_id: The external account number (int) or account ID Guid. (required) 3584 :return: FavoriteTemplatesInfo 3585 If the method is called asynchronously, 3586 returns the request thread. 3587 """ 3588 kwargs['_return_http_data_only'] = True 3589 if kwargs.get('callback'): 3590 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 3591 else: 3592 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 3593 return data 3594 3595 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 3596 """ 3597 Retrieves the list of favorited templates for this caller 3598 3599 This method makes a synchronous HTTP request by default. To make an 3600 asynchronous HTTP request, please define a `callback` function 3601 to be invoked when receiving the response. 3602 >>> def callback_function(response): 3603 >>> pprint(response) 3604 >>> 3605 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 3606 3607 :param callback function: The callback function 3608 for asynchronous request. (optional) 3609 :param str account_id: The external account number (int) or account ID Guid. (required) 3610 :return: FavoriteTemplatesInfo 3611 If the method is called asynchronously, 3612 returns the request thread. 3613 """ 3614 3615 all_params = ['account_id'] 3616 all_params.append('callback') 3617 all_params.append('_return_http_data_only') 3618 all_params.append('_preload_content') 3619 all_params.append('_request_timeout') 3620 3621 params = locals() 3622 for key, val in iteritems(params['kwargs']): 3623 if key not in all_params: 3624 raise TypeError( 3625 "Got an unexpected keyword argument '%s'" 3626 " to method get_favorite_templates" % key 3627 ) 3628 params[key] = val 3629 del params['kwargs'] 3630 # verify the required parameter 'account_id' is set 3631 if ('account_id' not in params) or (params['account_id'] is None): 3632 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 3633 3634 3635 collection_formats = {} 3636 3637 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 3638 path_params = {} 3639 if 'account_id' in params: 3640 path_params['accountId'] = params['account_id'] 3641 3642 query_params = {} 3643 3644 header_params = {} 3645 3646 form_params = [] 3647 local_var_files = {} 3648 3649 body_params = None 3650 # HTTP header `Accept` 3651 header_params['Accept'] = self.api_client.\ 3652 select_header_accept(['application/json']) 3653 3654 # Authentication setting 3655 auth_settings = [] 3656 3657 return self.api_client.call_api(resource_path, 'GET', 3658 path_params, 3659 query_params, 3660 header_params, 3661 body=body_params, 3662 post_params=form_params, 3663 files=local_var_files, 3664 response_type='FavoriteTemplatesInfo', 3665 auth_settings=auth_settings, 3666 callback=params.get('callback'), 3667 _return_http_data_only=params.get('_return_http_data_only'), 3668 _preload_content=params.get('_preload_content', True), 3669 _request_timeout=params.get('_request_timeout'), 3670 collection_formats=collection_formats) 3671 3672 def get_notification_defaults(self, account_id, **kwargs): 3673 """ 3674 Returns default user level settings for a specified account 3675 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 3676 This method makes a synchronous HTTP request by default. To make an 3677 asynchronous HTTP request, please define a `callback` function 3678 to be invoked when receiving the response. 3679 >>> def callback_function(response): 3680 >>> pprint(response) 3681 >>> 3682 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 3683 3684 :param callback function: The callback function 3685 for asynchronous request. (optional) 3686 :param str account_id: The external account number (int) or account ID Guid. (required) 3687 :return: NotificationDefaults 3688 If the method is called asynchronously, 3689 returns the request thread. 3690 """ 3691 kwargs['_return_http_data_only'] = True 3692 if kwargs.get('callback'): 3693 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 3694 else: 3695 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 3696 return data 3697 3698 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 3699 """ 3700 Returns default user level settings for a specified account 3701 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 3702 This method makes a synchronous HTTP request by default. To make an 3703 asynchronous HTTP request, please define a `callback` function 3704 to be invoked when receiving the response. 3705 >>> def callback_function(response): 3706 >>> pprint(response) 3707 >>> 3708 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 3709 3710 :param callback function: The callback function 3711 for asynchronous request. (optional) 3712 :param str account_id: The external account number (int) or account ID Guid. (required) 3713 :return: NotificationDefaults 3714 If the method is called asynchronously, 3715 returns the request thread. 3716 """ 3717 3718 all_params = ['account_id'] 3719 all_params.append('callback') 3720 all_params.append('_return_http_data_only') 3721 all_params.append('_preload_content') 3722 all_params.append('_request_timeout') 3723 3724 params = locals() 3725 for key, val in iteritems(params['kwargs']): 3726 if key not in all_params: 3727 raise TypeError( 3728 "Got an unexpected keyword argument '%s'" 3729 " to method get_notification_defaults" % key 3730 ) 3731 params[key] = val 3732 del params['kwargs'] 3733 # verify the required parameter 'account_id' is set 3734 if ('account_id' not in params) or (params['account_id'] is None): 3735 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 3736 3737 3738 collection_formats = {} 3739 3740 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 3741 path_params = {} 3742 if 'account_id' in params: 3743 path_params['accountId'] = params['account_id'] 3744 3745 query_params = {} 3746 3747 header_params = {} 3748 3749 form_params = [] 3750 local_var_files = {} 3751 3752 body_params = None 3753 # HTTP header `Accept` 3754 header_params['Accept'] = self.api_client.\ 3755 select_header_accept(['application/json']) 3756 3757 # Authentication setting 3758 auth_settings = [] 3759 3760 return self.api_client.call_api(resource_path, 'GET', 3761 path_params, 3762 query_params, 3763 header_params, 3764 body=body_params, 3765 post_params=form_params, 3766 files=local_var_files, 3767 response_type='NotificationDefaults', 3768 auth_settings=auth_settings, 3769 callback=params.get('callback'), 3770 _return_http_data_only=params.get('_return_http_data_only'), 3771 _preload_content=params.get('_preload_content', True), 3772 _request_timeout=params.get('_request_timeout'), 3773 collection_formats=collection_formats) 3774 3775 def get_password_rules(self, account_id, **kwargs): 3776 """ 3777 Get the password rules 3778 This method retrieves the password rules for an account. 3779 This method makes a synchronous HTTP request by default. To make an 3780 asynchronous HTTP request, please define a `callback` function 3781 to be invoked when receiving the response. 3782 >>> def callback_function(response): 3783 >>> pprint(response) 3784 >>> 3785 >>> thread = api.get_password_rules(account_id, callback=callback_function) 3786 3787 :param callback function: The callback function 3788 for asynchronous request. (optional) 3789 :param str account_id: The external account number (int) or account ID Guid. (required) 3790 :return: AccountPasswordRules 3791 If the method is called asynchronously, 3792 returns the request thread. 3793 """ 3794 kwargs['_return_http_data_only'] = True 3795 if kwargs.get('callback'): 3796 return self.get_password_rules_with_http_info(account_id, **kwargs) 3797 else: 3798 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 3799 return data 3800 3801 def get_password_rules_with_http_info(self, account_id, **kwargs): 3802 """ 3803 Get the password rules 3804 This method retrieves the password rules for an account. 3805 This method makes a synchronous HTTP request by default. To make an 3806 asynchronous HTTP request, please define a `callback` function 3807 to be invoked when receiving the response. 3808 >>> def callback_function(response): 3809 >>> pprint(response) 3810 >>> 3811 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 3812 3813 :param callback function: The callback function 3814 for asynchronous request. (optional) 3815 :param str account_id: The external account number (int) or account ID Guid. (required) 3816 :return: AccountPasswordRules 3817 If the method is called asynchronously, 3818 returns the request thread. 3819 """ 3820 3821 all_params = ['account_id'] 3822 all_params.append('callback') 3823 all_params.append('_return_http_data_only') 3824 all_params.append('_preload_content') 3825 all_params.append('_request_timeout') 3826 3827 params = locals() 3828 for key, val in iteritems(params['kwargs']): 3829 if key not in all_params: 3830 raise TypeError( 3831 "Got an unexpected keyword argument '%s'" 3832 " to method get_password_rules" % key 3833 ) 3834 params[key] = val 3835 del params['kwargs'] 3836 # verify the required parameter 'account_id' is set 3837 if ('account_id' not in params) or (params['account_id'] is None): 3838 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 3839 3840 3841 collection_formats = {} 3842 3843 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 3844 path_params = {} 3845 if 'account_id' in params: 3846 path_params['accountId'] = params['account_id'] 3847 3848 query_params = {} 3849 3850 header_params = {} 3851 3852 form_params = [] 3853 local_var_files = {} 3854 3855 body_params = None 3856 # HTTP header `Accept` 3857 header_params['Accept'] = self.api_client.\ 3858 select_header_accept(['application/json']) 3859 3860 # Authentication setting 3861 auth_settings = [] 3862 3863 return self.api_client.call_api(resource_path, 'GET', 3864 path_params, 3865 query_params, 3866 header_params, 3867 body=body_params, 3868 post_params=form_params, 3869 files=local_var_files, 3870 response_type='AccountPasswordRules', 3871 auth_settings=auth_settings, 3872 callback=params.get('callback'), 3873 _return_http_data_only=params.get('_return_http_data_only'), 3874 _preload_content=params.get('_preload_content', True), 3875 _request_timeout=params.get('_request_timeout'), 3876 collection_formats=collection_formats) 3877 3878 def get_password_rules_0(self, **kwargs): 3879 """ 3880 Get membership account password rules 3881 3882 This method makes a synchronous HTTP request by default. To make an 3883 asynchronous HTTP request, please define a `callback` function 3884 to be invoked when receiving the response. 3885 >>> def callback_function(response): 3886 >>> pprint(response) 3887 >>> 3888 >>> thread = api.get_password_rules_0(callback=callback_function) 3889 3890 :param callback function: The callback function 3891 for asynchronous request. (optional) 3892 :return: UserPasswordRules 3893 If the method is called asynchronously, 3894 returns the request thread. 3895 """ 3896 kwargs['_return_http_data_only'] = True 3897 if kwargs.get('callback'): 3898 return self.get_password_rules_0_with_http_info(**kwargs) 3899 else: 3900 (data) = self.get_password_rules_0_with_http_info(**kwargs) 3901 return data 3902 3903 def get_password_rules_0_with_http_info(self, **kwargs): 3904 """ 3905 Get membership account password rules 3906 3907 This method makes a synchronous HTTP request by default. To make an 3908 asynchronous HTTP request, please define a `callback` function 3909 to be invoked when receiving the response. 3910 >>> def callback_function(response): 3911 >>> pprint(response) 3912 >>> 3913 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 3914 3915 :param callback function: The callback function 3916 for asynchronous request. (optional) 3917 :return: UserPasswordRules 3918 If the method is called asynchronously, 3919 returns the request thread. 3920 """ 3921 3922 all_params = [] 3923 all_params.append('callback') 3924 all_params.append('_return_http_data_only') 3925 all_params.append('_preload_content') 3926 all_params.append('_request_timeout') 3927 3928 params = locals() 3929 for key, val in iteritems(params['kwargs']): 3930 if key not in all_params: 3931 raise TypeError( 3932 "Got an unexpected keyword argument '%s'" 3933 " to method get_password_rules_0" % key 3934 ) 3935 params[key] = val 3936 del params['kwargs'] 3937 3938 collection_formats = {} 3939 3940 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 3941 path_params = {} 3942 3943 query_params = {} 3944 3945 header_params = {} 3946 3947 form_params = [] 3948 local_var_files = {} 3949 3950 body_params = None 3951 # HTTP header `Accept` 3952 header_params['Accept'] = self.api_client.\ 3953 select_header_accept(['application/json']) 3954 3955 # Authentication setting 3956 auth_settings = [] 3957 3958 return self.api_client.call_api(resource_path, 'GET', 3959 path_params, 3960 query_params, 3961 header_params, 3962 body=body_params, 3963 post_params=form_params, 3964 files=local_var_files, 3965 response_type='UserPasswordRules', 3966 auth_settings=auth_settings, 3967 callback=params.get('callback'), 3968 _return_http_data_only=params.get('_return_http_data_only'), 3969 _preload_content=params.get('_preload_content', True), 3970 _request_timeout=params.get('_request_timeout'), 3971 collection_formats=collection_formats) 3972 3973 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 3974 """ 3975 Returns a permissions profile in the specified account. 3976 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 3977 This method makes a synchronous HTTP request by default. To make an 3978 asynchronous HTTP request, please define a `callback` function 3979 to be invoked when receiving the response. 3980 >>> def callback_function(response): 3981 >>> pprint(response) 3982 >>> 3983 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 3984 3985 :param callback function: The callback function 3986 for asynchronous request. (optional) 3987 :param str account_id: The external account number (int) or account ID Guid. (required) 3988 :param str permission_profile_id: (required) 3989 :param str include: 3990 :return: PermissionProfile 3991 If the method is called asynchronously, 3992 returns the request thread. 3993 """ 3994 kwargs['_return_http_data_only'] = True 3995 if kwargs.get('callback'): 3996 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 3997 else: 3998 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 3999 return data 4000 4001 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4002 """ 4003 Returns a permissions profile in the specified account. 4004 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4005 This method makes a synchronous HTTP request by default. To make an 4006 asynchronous HTTP request, please define a `callback` function 4007 to be invoked when receiving the response. 4008 >>> def callback_function(response): 4009 >>> pprint(response) 4010 >>> 4011 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4012 4013 :param callback function: The callback function 4014 for asynchronous request. (optional) 4015 :param str account_id: The external account number (int) or account ID Guid. (required) 4016 :param str permission_profile_id: (required) 4017 :param str include: 4018 :return: PermissionProfile 4019 If the method is called asynchronously, 4020 returns the request thread. 4021 """ 4022 4023 all_params = ['account_id', 'permission_profile_id', 'include'] 4024 all_params.append('callback') 4025 all_params.append('_return_http_data_only') 4026 all_params.append('_preload_content') 4027 all_params.append('_request_timeout') 4028 4029 params = locals() 4030 for key, val in iteritems(params['kwargs']): 4031 if key not in all_params: 4032 raise TypeError( 4033 "Got an unexpected keyword argument '%s'" 4034 " to method get_permission_profile" % key 4035 ) 4036 params[key] = val 4037 del params['kwargs'] 4038 # verify the required parameter 'account_id' is set 4039 if ('account_id' not in params) or (params['account_id'] is None): 4040 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4041 # verify the required parameter 'permission_profile_id' is set 4042 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4043 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4044 4045 4046 collection_formats = {} 4047 4048 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4049 path_params = {} 4050 if 'account_id' in params: 4051 path_params['accountId'] = params['account_id'] 4052 if 'permission_profile_id' in params: 4053 path_params['permissionProfileId'] = params['permission_profile_id'] 4054 4055 query_params = {} 4056 if 'include' in params: 4057 query_params['include'] = params['include'] 4058 4059 header_params = {} 4060 4061 form_params = [] 4062 local_var_files = {} 4063 4064 body_params = None 4065 # HTTP header `Accept` 4066 header_params['Accept'] = self.api_client.\ 4067 select_header_accept(['application/json']) 4068 4069 # Authentication setting 4070 auth_settings = [] 4071 4072 return self.api_client.call_api(resource_path, 'GET', 4073 path_params, 4074 query_params, 4075 header_params, 4076 body=body_params, 4077 post_params=form_params, 4078 files=local_var_files, 4079 response_type='PermissionProfile', 4080 auth_settings=auth_settings, 4081 callback=params.get('callback'), 4082 _return_http_data_only=params.get('_return_http_data_only'), 4083 _preload_content=params.get('_preload_content', True), 4084 _request_timeout=params.get('_request_timeout'), 4085 collection_formats=collection_formats) 4086 4087 def get_provisioning(self, **kwargs): 4088 """ 4089 Retrieves the account provisioning information for the account. 4090 Retrieves the account provisioning information for the account. 4091 This method makes a synchronous HTTP request by default. To make an 4092 asynchronous HTTP request, please define a `callback` function 4093 to be invoked when receiving the response. 4094 >>> def callback_function(response): 4095 >>> pprint(response) 4096 >>> 4097 >>> thread = api.get_provisioning(callback=callback_function) 4098 4099 :param callback function: The callback function 4100 for asynchronous request. (optional) 4101 :return: ProvisioningInformation 4102 If the method is called asynchronously, 4103 returns the request thread. 4104 """ 4105 kwargs['_return_http_data_only'] = True 4106 if kwargs.get('callback'): 4107 return self.get_provisioning_with_http_info(**kwargs) 4108 else: 4109 (data) = self.get_provisioning_with_http_info(**kwargs) 4110 return data 4111 4112 def get_provisioning_with_http_info(self, **kwargs): 4113 """ 4114 Retrieves the account provisioning information for the account. 4115 Retrieves the account provisioning information for the account. 4116 This method makes a synchronous HTTP request by default. To make an 4117 asynchronous HTTP request, please define a `callback` function 4118 to be invoked when receiving the response. 4119 >>> def callback_function(response): 4120 >>> pprint(response) 4121 >>> 4122 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4123 4124 :param callback function: The callback function 4125 for asynchronous request. (optional) 4126 :return: ProvisioningInformation 4127 If the method is called asynchronously, 4128 returns the request thread. 4129 """ 4130 4131 all_params = [] 4132 all_params.append('callback') 4133 all_params.append('_return_http_data_only') 4134 all_params.append('_preload_content') 4135 all_params.append('_request_timeout') 4136 4137 params = locals() 4138 for key, val in iteritems(params['kwargs']): 4139 if key not in all_params: 4140 raise TypeError( 4141 "Got an unexpected keyword argument '%s'" 4142 " to method get_provisioning" % key 4143 ) 4144 params[key] = val 4145 del params['kwargs'] 4146 4147 collection_formats = {} 4148 4149 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4150 path_params = {} 4151 4152 query_params = {} 4153 4154 header_params = {} 4155 4156 form_params = [] 4157 local_var_files = {} 4158 4159 body_params = None 4160 # HTTP header `Accept` 4161 header_params['Accept'] = self.api_client.\ 4162 select_header_accept(['application/json']) 4163 4164 # Authentication setting 4165 auth_settings = [] 4166 4167 return self.api_client.call_api(resource_path, 'GET', 4168 path_params, 4169 query_params, 4170 header_params, 4171 body=body_params, 4172 post_params=form_params, 4173 files=local_var_files, 4174 response_type='ProvisioningInformation', 4175 auth_settings=auth_settings, 4176 callback=params.get('callback'), 4177 _return_http_data_only=params.get('_return_http_data_only'), 4178 _preload_content=params.get('_preload_content', True), 4179 _request_timeout=params.get('_request_timeout'), 4180 collection_formats=collection_formats) 4181 4182 def get_supported_languages(self, account_id, **kwargs): 4183 """ 4184 Gets list of supported languages for recipient language setting. 4185 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4186 This method makes a synchronous HTTP request by default. To make an 4187 asynchronous HTTP request, please define a `callback` function 4188 to be invoked when receiving the response. 4189 >>> def callback_function(response): 4190 >>> pprint(response) 4191 >>> 4192 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4193 4194 :param callback function: The callback function 4195 for asynchronous request. (optional) 4196 :param str account_id: The external account number (int) or account ID Guid. (required) 4197 :return: SupportedLanguages 4198 If the method is called asynchronously, 4199 returns the request thread. 4200 """ 4201 kwargs['_return_http_data_only'] = True 4202 if kwargs.get('callback'): 4203 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4204 else: 4205 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4206 return data 4207 4208 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4209 """ 4210 Gets list of supported languages for recipient language setting. 4211 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4212 This method makes a synchronous HTTP request by default. To make an 4213 asynchronous HTTP request, please define a `callback` function 4214 to be invoked when receiving the response. 4215 >>> def callback_function(response): 4216 >>> pprint(response) 4217 >>> 4218 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4219 4220 :param callback function: The callback function 4221 for asynchronous request. (optional) 4222 :param str account_id: The external account number (int) or account ID Guid. (required) 4223 :return: SupportedLanguages 4224 If the method is called asynchronously, 4225 returns the request thread. 4226 """ 4227 4228 all_params = ['account_id'] 4229 all_params.append('callback') 4230 all_params.append('_return_http_data_only') 4231 all_params.append('_preload_content') 4232 all_params.append('_request_timeout') 4233 4234 params = locals() 4235 for key, val in iteritems(params['kwargs']): 4236 if key not in all_params: 4237 raise TypeError( 4238 "Got an unexpected keyword argument '%s'" 4239 " to method get_supported_languages" % key 4240 ) 4241 params[key] = val 4242 del params['kwargs'] 4243 # verify the required parameter 'account_id' is set 4244 if ('account_id' not in params) or (params['account_id'] is None): 4245 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4246 4247 4248 collection_formats = {} 4249 4250 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4251 path_params = {} 4252 if 'account_id' in params: 4253 path_params['accountId'] = params['account_id'] 4254 4255 query_params = {} 4256 4257 header_params = {} 4258 4259 form_params = [] 4260 local_var_files = {} 4261 4262 body_params = None 4263 # HTTP header `Accept` 4264 header_params['Accept'] = self.api_client.\ 4265 select_header_accept(['application/json']) 4266 4267 # Authentication setting 4268 auth_settings = [] 4269 4270 return self.api_client.call_api(resource_path, 'GET', 4271 path_params, 4272 query_params, 4273 header_params, 4274 body=body_params, 4275 post_params=form_params, 4276 files=local_var_files, 4277 response_type='SupportedLanguages', 4278 auth_settings=auth_settings, 4279 callback=params.get('callback'), 4280 _return_http_data_only=params.get('_return_http_data_only'), 4281 _preload_content=params.get('_preload_content', True), 4282 _request_timeout=params.get('_request_timeout'), 4283 collection_formats=collection_formats) 4284 4285 def get_watermark(self, account_id, **kwargs): 4286 """ 4287 Get watermark information. 4288 4289 This method makes a synchronous HTTP request by default. To make an 4290 asynchronous HTTP request, please define a `callback` function 4291 to be invoked when receiving the response. 4292 >>> def callback_function(response): 4293 >>> pprint(response) 4294 >>> 4295 >>> thread = api.get_watermark(account_id, callback=callback_function) 4296 4297 :param callback function: The callback function 4298 for asynchronous request. (optional) 4299 :param str account_id: The external account number (int) or account ID Guid. (required) 4300 :return: Watermark 4301 If the method is called asynchronously, 4302 returns the request thread. 4303 """ 4304 kwargs['_return_http_data_only'] = True 4305 if kwargs.get('callback'): 4306 return self.get_watermark_with_http_info(account_id, **kwargs) 4307 else: 4308 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 4309 return data 4310 4311 def get_watermark_with_http_info(self, account_id, **kwargs): 4312 """ 4313 Get watermark information. 4314 4315 This method makes a synchronous HTTP request by default. To make an 4316 asynchronous HTTP request, please define a `callback` function 4317 to be invoked when receiving the response. 4318 >>> def callback_function(response): 4319 >>> pprint(response) 4320 >>> 4321 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 4322 4323 :param callback function: The callback function 4324 for asynchronous request. (optional) 4325 :param str account_id: The external account number (int) or account ID Guid. (required) 4326 :return: Watermark 4327 If the method is called asynchronously, 4328 returns the request thread. 4329 """ 4330 4331 all_params = ['account_id'] 4332 all_params.append('callback') 4333 all_params.append('_return_http_data_only') 4334 all_params.append('_preload_content') 4335 all_params.append('_request_timeout') 4336 4337 params = locals() 4338 for key, val in iteritems(params['kwargs']): 4339 if key not in all_params: 4340 raise TypeError( 4341 "Got an unexpected keyword argument '%s'" 4342 " to method get_watermark" % key 4343 ) 4344 params[key] = val 4345 del params['kwargs'] 4346 # verify the required parameter 'account_id' is set 4347 if ('account_id' not in params) or (params['account_id'] is None): 4348 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 4349 4350 4351 collection_formats = {} 4352 4353 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 4354 path_params = {} 4355 if 'account_id' in params: 4356 path_params['accountId'] = params['account_id'] 4357 4358 query_params = {} 4359 4360 header_params = {} 4361 4362 form_params = [] 4363 local_var_files = {} 4364 4365 body_params = None 4366 # HTTP header `Accept` 4367 header_params['Accept'] = self.api_client.\ 4368 select_header_accept(['application/json']) 4369 4370 # Authentication setting 4371 auth_settings = [] 4372 4373 return self.api_client.call_api(resource_path, 'GET', 4374 path_params, 4375 query_params, 4376 header_params, 4377 body=body_params, 4378 post_params=form_params, 4379 files=local_var_files, 4380 response_type='Watermark', 4381 auth_settings=auth_settings, 4382 callback=params.get('callback'), 4383 _return_http_data_only=params.get('_return_http_data_only'), 4384 _preload_content=params.get('_preload_content', True), 4385 _request_timeout=params.get('_request_timeout'), 4386 collection_formats=collection_formats) 4387 4388 def get_watermark_preview(self, account_id, **kwargs): 4389 """ 4390 Get watermark preview. 4391 4392 This method makes a synchronous HTTP request by default. To make an 4393 asynchronous HTTP request, please define a `callback` function 4394 to be invoked when receiving the response. 4395 >>> def callback_function(response): 4396 >>> pprint(response) 4397 >>> 4398 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 4399 4400 :param callback function: The callback function 4401 for asynchronous request. (optional) 4402 :param str account_id: The external account number (int) or account ID Guid. (required) 4403 :param Watermark watermark: 4404 :return: Watermark 4405 If the method is called asynchronously, 4406 returns the request thread. 4407 """ 4408 kwargs['_return_http_data_only'] = True 4409 if kwargs.get('callback'): 4410 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 4411 else: 4412 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 4413 return data 4414 4415 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 4416 """ 4417 Get watermark preview. 4418 4419 This method makes a synchronous HTTP request by default. To make an 4420 asynchronous HTTP request, please define a `callback` function 4421 to be invoked when receiving the response. 4422 >>> def callback_function(response): 4423 >>> pprint(response) 4424 >>> 4425 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 4426 4427 :param callback function: The callback function 4428 for asynchronous request. (optional) 4429 :param str account_id: The external account number (int) or account ID Guid. (required) 4430 :param Watermark watermark: 4431 :return: Watermark 4432 If the method is called asynchronously, 4433 returns the request thread. 4434 """ 4435 4436 all_params = ['account_id', 'watermark'] 4437 all_params.append('callback') 4438 all_params.append('_return_http_data_only') 4439 all_params.append('_preload_content') 4440 all_params.append('_request_timeout') 4441 4442 params = locals() 4443 for key, val in iteritems(params['kwargs']): 4444 if key not in all_params: 4445 raise TypeError( 4446 "Got an unexpected keyword argument '%s'" 4447 " to method get_watermark_preview" % key 4448 ) 4449 params[key] = val 4450 del params['kwargs'] 4451 # verify the required parameter 'account_id' is set 4452 if ('account_id' not in params) or (params['account_id'] is None): 4453 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 4454 4455 4456 collection_formats = {} 4457 4458 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 4459 path_params = {} 4460 if 'account_id' in params: 4461 path_params['accountId'] = params['account_id'] 4462 4463 query_params = {} 4464 4465 header_params = {} 4466 4467 form_params = [] 4468 local_var_files = {} 4469 4470 body_params = None 4471 if 'watermark' in params: 4472 body_params = params['watermark'] 4473 # HTTP header `Accept` 4474 header_params['Accept'] = self.api_client.\ 4475 select_header_accept(['application/json']) 4476 4477 # Authentication setting 4478 auth_settings = [] 4479 4480 return self.api_client.call_api(resource_path, 'PUT', 4481 path_params, 4482 query_params, 4483 header_params, 4484 body=body_params, 4485 post_params=form_params, 4486 files=local_var_files, 4487 response_type='Watermark', 4488 auth_settings=auth_settings, 4489 callback=params.get('callback'), 4490 _return_http_data_only=params.get('_return_http_data_only'), 4491 _preload_content=params.get('_preload_content', True), 4492 _request_timeout=params.get('_request_timeout'), 4493 collection_formats=collection_formats) 4494 4495 def list_brands(self, account_id, **kwargs): 4496 """ 4497 Gets a list of brand profiles. 4498 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 4499 This method makes a synchronous HTTP request by default. To make an 4500 asynchronous HTTP request, please define a `callback` function 4501 to be invoked when receiving the response. 4502 >>> def callback_function(response): 4503 >>> pprint(response) 4504 >>> 4505 >>> thread = api.list_brands(account_id, callback=callback_function) 4506 4507 :param callback function: The callback function 4508 for asynchronous request. (optional) 4509 :param str account_id: The external account number (int) or account ID Guid. (required) 4510 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 4511 :param str include_logos: When set to **true**, returns the logos associated with the brand. 4512 :return: BrandsResponse 4513 If the method is called asynchronously, 4514 returns the request thread. 4515 """ 4516 kwargs['_return_http_data_only'] = True 4517 if kwargs.get('callback'): 4518 return self.list_brands_with_http_info(account_id, **kwargs) 4519 else: 4520 (data) = self.list_brands_with_http_info(account_id, **kwargs) 4521 return data 4522 4523 def list_brands_with_http_info(self, account_id, **kwargs): 4524 """ 4525 Gets a list of brand profiles. 4526 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 4527 This method makes a synchronous HTTP request by default. To make an 4528 asynchronous HTTP request, please define a `callback` function 4529 to be invoked when receiving the response. 4530 >>> def callback_function(response): 4531 >>> pprint(response) 4532 >>> 4533 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 4534 4535 :param callback function: The callback function 4536 for asynchronous request. (optional) 4537 :param str account_id: The external account number (int) or account ID Guid. (required) 4538 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 4539 :param str include_logos: When set to **true**, returns the logos associated with the brand. 4540 :return: BrandsResponse 4541 If the method is called asynchronously, 4542 returns the request thread. 4543 """ 4544 4545 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 4546 all_params.append('callback') 4547 all_params.append('_return_http_data_only') 4548 all_params.append('_preload_content') 4549 all_params.append('_request_timeout') 4550 4551 params = locals() 4552 for key, val in iteritems(params['kwargs']): 4553 if key not in all_params: 4554 raise TypeError( 4555 "Got an unexpected keyword argument '%s'" 4556 " to method list_brands" % key 4557 ) 4558 params[key] = val 4559 del params['kwargs'] 4560 # verify the required parameter 'account_id' is set 4561 if ('account_id' not in params) or (params['account_id'] is None): 4562 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 4563 4564 4565 collection_formats = {} 4566 4567 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 4568 path_params = {} 4569 if 'account_id' in params: 4570 path_params['accountId'] = params['account_id'] 4571 4572 query_params = {} 4573 if 'exclude_distributor_brand' in params: 4574 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 4575 if 'include_logos' in params: 4576 query_params['include_logos'] = params['include_logos'] 4577 4578 header_params = {} 4579 4580 form_params = [] 4581 local_var_files = {} 4582 4583 body_params = None 4584 # HTTP header `Accept` 4585 header_params['Accept'] = self.api_client.\ 4586 select_header_accept(['application/json']) 4587 4588 # Authentication setting 4589 auth_settings = [] 4590 4591 return self.api_client.call_api(resource_path, 'GET', 4592 path_params, 4593 query_params, 4594 header_params, 4595 body=body_params, 4596 post_params=form_params, 4597 files=local_var_files, 4598 response_type='BrandsResponse', 4599 auth_settings=auth_settings, 4600 callback=params.get('callback'), 4601 _return_http_data_only=params.get('_return_http_data_only'), 4602 _preload_content=params.get('_preload_content', True), 4603 _request_timeout=params.get('_request_timeout'), 4604 collection_formats=collection_formats) 4605 4606 def list_custom_fields(self, account_id, **kwargs): 4607 """ 4608 Gets a list of custom fields associated with the account. 4609 Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. 4610 This method makes a synchronous HTTP request by default. To make an 4611 asynchronous HTTP request, please define a `callback` function 4612 to be invoked when receiving the response. 4613 >>> def callback_function(response): 4614 >>> pprint(response) 4615 >>> 4616 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 4617 4618 :param callback function: The callback function 4619 for asynchronous request. (optional) 4620 :param str account_id: The external account number (int) or account ID Guid. (required) 4621 :return: CustomFields 4622 If the method is called asynchronously, 4623 returns the request thread. 4624 """ 4625 kwargs['_return_http_data_only'] = True 4626 if kwargs.get('callback'): 4627 return self.list_custom_fields_with_http_info(account_id, **kwargs) 4628 else: 4629 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 4630 return data 4631 4632 def list_custom_fields_with_http_info(self, account_id, **kwargs): 4633 """ 4634 Gets a list of custom fields associated with the account. 4635 Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. 4636 This method makes a synchronous HTTP request by default. To make an 4637 asynchronous HTTP request, please define a `callback` function 4638 to be invoked when receiving the response. 4639 >>> def callback_function(response): 4640 >>> pprint(response) 4641 >>> 4642 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 4643 4644 :param callback function: The callback function 4645 for asynchronous request. (optional) 4646 :param str account_id: The external account number (int) or account ID Guid. (required) 4647 :return: CustomFields 4648 If the method is called asynchronously, 4649 returns the request thread. 4650 """ 4651 4652 all_params = ['account_id'] 4653 all_params.append('callback') 4654 all_params.append('_return_http_data_only') 4655 all_params.append('_preload_content') 4656 all_params.append('_request_timeout') 4657 4658 params = locals() 4659 for key, val in iteritems(params['kwargs']): 4660 if key not in all_params: 4661 raise TypeError( 4662 "Got an unexpected keyword argument '%s'" 4663 " to method list_custom_fields" % key 4664 ) 4665 params[key] = val 4666 del params['kwargs'] 4667 # verify the required parameter 'account_id' is set 4668 if ('account_id' not in params) or (params['account_id'] is None): 4669 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 4670 4671 4672 collection_formats = {} 4673 4674 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 4675 path_params = {} 4676 if 'account_id' in params: 4677 path_params['accountId'] = params['account_id'] 4678 4679 query_params = {} 4680 4681 header_params = {} 4682 4683 form_params = [] 4684 local_var_files = {} 4685 4686 body_params = None 4687 # HTTP header `Accept` 4688 header_params['Accept'] = self.api_client.\ 4689 select_header_accept(['application/json']) 4690 4691 # Authentication setting 4692 auth_settings = [] 4693 4694 return self.api_client.call_api(resource_path, 'GET', 4695 path_params, 4696 query_params, 4697 header_params, 4698 body=body_params, 4699 post_params=form_params, 4700 files=local_var_files, 4701 response_type='CustomFields', 4702 auth_settings=auth_settings, 4703 callback=params.get('callback'), 4704 _return_http_data_only=params.get('_return_http_data_only'), 4705 _preload_content=params.get('_preload_content', True), 4706 _request_timeout=params.get('_request_timeout'), 4707 collection_formats=collection_formats) 4708 4709 def list_permissions(self, account_id, **kwargs): 4710 """ 4711 Gets a list of permission profiles. 4712 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 4713 This method makes a synchronous HTTP request by default. To make an 4714 asynchronous HTTP request, please define a `callback` function 4715 to be invoked when receiving the response. 4716 >>> def callback_function(response): 4717 >>> pprint(response) 4718 >>> 4719 >>> thread = api.list_permissions(account_id, callback=callback_function) 4720 4721 :param callback function: The callback function 4722 for asynchronous request. (optional) 4723 :param str account_id: The external account number (int) or account ID Guid. (required) 4724 :param str include: 4725 :return: PermissionProfileInformation 4726 If the method is called asynchronously, 4727 returns the request thread. 4728 """ 4729 kwargs['_return_http_data_only'] = True 4730 if kwargs.get('callback'): 4731 return self.list_permissions_with_http_info(account_id, **kwargs) 4732 else: 4733 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 4734 return data 4735 4736 def list_permissions_with_http_info(self, account_id, **kwargs): 4737 """ 4738 Gets a list of permission profiles. 4739 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 4740 This method makes a synchronous HTTP request by default. To make an 4741 asynchronous HTTP request, please define a `callback` function 4742 to be invoked when receiving the response. 4743 >>> def callback_function(response): 4744 >>> pprint(response) 4745 >>> 4746 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 4747 4748 :param callback function: The callback function 4749 for asynchronous request. (optional) 4750 :param str account_id: The external account number (int) or account ID Guid. (required) 4751 :param str include: 4752 :return: PermissionProfileInformation 4753 If the method is called asynchronously, 4754 returns the request thread. 4755 """ 4756 4757 all_params = ['account_id', 'include'] 4758 all_params.append('callback') 4759 all_params.append('_return_http_data_only') 4760 all_params.append('_preload_content') 4761 all_params.append('_request_timeout') 4762 4763 params = locals() 4764 for key, val in iteritems(params['kwargs']): 4765 if key not in all_params: 4766 raise TypeError( 4767 "Got an unexpected keyword argument '%s'" 4768 " to method list_permissions" % key 4769 ) 4770 params[key] = val 4771 del params['kwargs'] 4772 # verify the required parameter 'account_id' is set 4773 if ('account_id' not in params) or (params['account_id'] is None): 4774 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 4775 4776 4777 collection_formats = {} 4778 4779 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 4780 path_params = {} 4781 if 'account_id' in params: 4782 path_params['accountId'] = params['account_id'] 4783 4784 query_params = {} 4785 if 'include' in params: 4786 query_params['include'] = params['include'] 4787 4788 header_params = {} 4789 4790 form_params = [] 4791 local_var_files = {} 4792 4793 body_params = None 4794 # HTTP header `Accept` 4795 header_params['Accept'] = self.api_client.\ 4796 select_header_accept(['application/json']) 4797 4798 # Authentication setting 4799 auth_settings = [] 4800 4801 return self.api_client.call_api(resource_path, 'GET', 4802 path_params, 4803 query_params, 4804 header_params, 4805 body=body_params, 4806 post_params=form_params, 4807 files=local_var_files, 4808 response_type='PermissionProfileInformation', 4809 auth_settings=auth_settings, 4810 callback=params.get('callback'), 4811 _return_http_data_only=params.get('_return_http_data_only'), 4812 _preload_content=params.get('_preload_content', True), 4813 _request_timeout=params.get('_request_timeout'), 4814 collection_formats=collection_formats) 4815 4816 def list_recipient_names_by_email(self, account_id, **kwargs): 4817 """ 4818 Gets recipient names associated with an email address. 4819 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 4820 This method makes a synchronous HTTP request by default. To make an 4821 asynchronous HTTP request, please define a `callback` function 4822 to be invoked when receiving the response. 4823 >>> def callback_function(response): 4824 >>> pprint(response) 4825 >>> 4826 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 4827 4828 :param callback function: The callback function 4829 for asynchronous request. (optional) 4830 :param str account_id: The external account number (int) or account ID Guid. (required) 4831 :param str email: The email address for the user 4832 :return: RecipientNamesResponse 4833 If the method is called asynchronously, 4834 returns the request thread. 4835 """ 4836 kwargs['_return_http_data_only'] = True 4837 if kwargs.get('callback'): 4838 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 4839 else: 4840 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 4841 return data 4842 4843 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 4844 """ 4845 Gets recipient names associated with an email address. 4846 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 4847 This method makes a synchronous HTTP request by default. To make an 4848 asynchronous HTTP request, please define a `callback` function 4849 to be invoked when receiving the response. 4850 >>> def callback_function(response): 4851 >>> pprint(response) 4852 >>> 4853 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 4854 4855 :param callback function: The callback function 4856 for asynchronous request. (optional) 4857 :param str account_id: The external account number (int) or account ID Guid. (required) 4858 :param str email: The email address for the user 4859 :return: RecipientNamesResponse 4860 If the method is called asynchronously, 4861 returns the request thread. 4862 """ 4863 4864 all_params = ['account_id', 'email'] 4865 all_params.append('callback') 4866 all_params.append('_return_http_data_only') 4867 all_params.append('_preload_content') 4868 all_params.append('_request_timeout') 4869 4870 params = locals() 4871 for key, val in iteritems(params['kwargs']): 4872 if key not in all_params: 4873 raise TypeError( 4874 "Got an unexpected keyword argument '%s'" 4875 " to method list_recipient_names_by_email" % key 4876 ) 4877 params[key] = val 4878 del params['kwargs'] 4879 # verify the required parameter 'account_id' is set 4880 if ('account_id' not in params) or (params['account_id'] is None): 4881 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 4882 4883 4884 collection_formats = {} 4885 4886 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 4887 path_params = {} 4888 if 'account_id' in params: 4889 path_params['accountId'] = params['account_id'] 4890 4891 query_params = {} 4892 if 'email' in params: 4893 query_params['email'] = params['email'] 4894 4895 header_params = {} 4896 4897 form_params = [] 4898 local_var_files = {} 4899 4900 body_params = None 4901 # HTTP header `Accept` 4902 header_params['Accept'] = self.api_client.\ 4903 select_header_accept(['application/json']) 4904 4905 # Authentication setting 4906 auth_settings = [] 4907 4908 return self.api_client.call_api(resource_path, 'GET', 4909 path_params, 4910 query_params, 4911 header_params, 4912 body=body_params, 4913 post_params=form_params, 4914 files=local_var_files, 4915 response_type='RecipientNamesResponse', 4916 auth_settings=auth_settings, 4917 callback=params.get('callback'), 4918 _return_http_data_only=params.get('_return_http_data_only'), 4919 _preload_content=params.get('_preload_content', True), 4920 _request_timeout=params.get('_request_timeout'), 4921 collection_formats=collection_formats) 4922 4923 def list_settings(self, account_id, **kwargs): 4924 """ 4925 Gets account settings information. 4926 Retrieves the account settings information for the specified account. 4927 This method makes a synchronous HTTP request by default. To make an 4928 asynchronous HTTP request, please define a `callback` function 4929 to be invoked when receiving the response. 4930 >>> def callback_function(response): 4931 >>> pprint(response) 4932 >>> 4933 >>> thread = api.list_settings(account_id, callback=callback_function) 4934 4935 :param callback function: The callback function 4936 for asynchronous request. (optional) 4937 :param str account_id: The external account number (int) or account ID Guid. (required) 4938 :return: AccountSettingsInformation 4939 If the method is called asynchronously, 4940 returns the request thread. 4941 """ 4942 kwargs['_return_http_data_only'] = True 4943 if kwargs.get('callback'): 4944 return self.list_settings_with_http_info(account_id, **kwargs) 4945 else: 4946 (data) = self.list_settings_with_http_info(account_id, **kwargs) 4947 return data 4948 4949 def list_settings_with_http_info(self, account_id, **kwargs): 4950 """ 4951 Gets account settings information. 4952 Retrieves the account settings information for the specified account. 4953 This method makes a synchronous HTTP request by default. To make an 4954 asynchronous HTTP request, please define a `callback` function 4955 to be invoked when receiving the response. 4956 >>> def callback_function(response): 4957 >>> pprint(response) 4958 >>> 4959 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 4960 4961 :param callback function: The callback function 4962 for asynchronous request. (optional) 4963 :param str account_id: The external account number (int) or account ID Guid. (required) 4964 :return: AccountSettingsInformation 4965 If the method is called asynchronously, 4966 returns the request thread. 4967 """ 4968 4969 all_params = ['account_id'] 4970 all_params.append('callback') 4971 all_params.append('_return_http_data_only') 4972 all_params.append('_preload_content') 4973 all_params.append('_request_timeout') 4974 4975 params = locals() 4976 for key, val in iteritems(params['kwargs']): 4977 if key not in all_params: 4978 raise TypeError( 4979 "Got an unexpected keyword argument '%s'" 4980 " to method list_settings" % key 4981 ) 4982 params[key] = val 4983 del params['kwargs'] 4984 # verify the required parameter 'account_id' is set 4985 if ('account_id' not in params) or (params['account_id'] is None): 4986 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 4987 4988 4989 collection_formats = {} 4990 4991 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 4992 path_params = {} 4993 if 'account_id' in params: 4994 path_params['accountId'] = params['account_id'] 4995 4996 query_params = {} 4997 4998 header_params = {} 4999 5000 form_params = [] 5001 local_var_files = {} 5002 5003 body_params = None 5004 # HTTP header `Accept` 5005 header_params['Accept'] = self.api_client.\ 5006 select_header_accept(['application/json']) 5007 5008 # Authentication setting 5009 auth_settings = [] 5010 5011 return self.api_client.call_api(resource_path, 'GET', 5012 path_params, 5013 query_params, 5014 header_params, 5015 body=body_params, 5016 post_params=form_params, 5017 files=local_var_files, 5018 response_type='AccountSettingsInformation', 5019 auth_settings=auth_settings, 5020 callback=params.get('callback'), 5021 _return_http_data_only=params.get('_return_http_data_only'), 5022 _preload_content=params.get('_preload_content', True), 5023 _request_timeout=params.get('_request_timeout'), 5024 collection_formats=collection_formats) 5025 5026 def list_shared_access(self, account_id, **kwargs): 5027 """ 5028 Reserved: Gets the shared item status for one or more users. 5029 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5030 This method makes a synchronous HTTP request by default. To make an 5031 asynchronous HTTP request, please define a `callback` function 5032 to be invoked when receiving the response. 5033 >>> def callback_function(response): 5034 >>> pprint(response) 5035 >>> 5036 >>> thread = api.list_shared_access(account_id, callback=callback_function) 5037 5038 :param callback function: The callback function 5039 for asynchronous request. (optional) 5040 :param str account_id: The external account number (int) or account ID Guid. (required) 5041 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5042 :param str envelopes_not_shared_user_status: 5043 :param str folder_ids: 5044 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5045 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5046 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5047 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5048 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5049 :return: AccountSharedAccess 5050 If the method is called asynchronously, 5051 returns the request thread. 5052 """ 5053 kwargs['_return_http_data_only'] = True 5054 if kwargs.get('callback'): 5055 return self.list_shared_access_with_http_info(account_id, **kwargs) 5056 else: 5057 (data) = self.list_shared_access_with_http_info(account_id, **kwargs) 5058 return data 5059 5060 def list_shared_access_with_http_info(self, account_id, **kwargs): 5061 """ 5062 Reserved: Gets the shared item status for one or more users. 5063 Reserved: Retrieves shared item status for one or more users and types of items. Users with account administration privileges can retrieve shared access information for all account users. Users without account administrator privileges can only retrieve shared access information for themselves and the returned information is limited to the retrieving the status of all members of the account that are sharing their folders to the user. This is equivalent to setting the shared=shared_from. 5064 This method makes a synchronous HTTP request by default. To make an 5065 asynchronous HTTP request, please define a `callback` function 5066 to be invoked when receiving the response. 5067 >>> def callback_function(response): 5068 >>> pprint(response) 5069 >>> 5070 >>> thread = api.list_shared_access_with_http_info(account_id, callback=callback_function) 5071 5072 :param callback function: The callback function 5073 for asynchronous request. (optional) 5074 :param str account_id: The external account number (int) or account ID Guid. (required) 5075 :param str count: Specifies maximum number of results included in the response. If no value is specified, this defaults to 1000. 5076 :param str envelopes_not_shared_user_status: 5077 :param str folder_ids: 5078 :param str item_type: Specifies the type of shared item being requested. The accepted values are: -envelopes: returns information about envelope sharing between users. 5079 :param str search_text: This can be used to filter user names in the response. The wild-card '*' (asterisk) can be used around the string. 5080 :param str shared: Specifies which users should be included in the response. Multiple values can be used in the query by using a comma separated list of shared values. If the requestor does not have account administrator privileges, the shared_to value is used. Requestors that do not have account administrator privileges can only use the shared_to, any other setting will result in an error. The accepted values are: -not_shared: Returns account users that the specified item type is not being shared with and that are not sharing the specified item type with the user. User X (Share) X Account user -shared_to: Returns account users that the specified item type is not being shared with and who are sharing the specified item type with the user (only shared to the user). User X (Share) Account user -shared_from: Returns account users that the specified item type is being shared with and who are not sharing the specified item type with the user (only shared from the user). User (Share) >> Account user -shared_to_and_from: Returns account users that the specified item type is being shared with and who are sharing the specified item type with the user. User << (Share) >> Account user 5081 :param str start_position: If the response set exceeds Count, this can be used to specify that the method should return users starting at the specified index. The first index is 0, and should be used in the first GET call. Typically this number is a multiple of Count. If no value is specified, this defaults to be 0. 5082 :param str user_ids: A comma separated list of userIds for whom the shared item information is being requested. 5083 :return: AccountSharedAccess 5084 If the method is called asynchronously, 5085 returns the request thread. 5086 """ 5087 5088 all_params = ['account_id', 'count', 'envelopes_not_shared_user_status', 'folder_ids', 'item_type', 'search_text', 'shared', 'start_position', 'user_ids'] 5089 all_params.append('callback') 5090 all_params.append('_return_http_data_only') 5091 all_params.append('_preload_content') 5092 all_params.append('_request_timeout') 5093 5094 params = locals() 5095 for key, val in iteritems(params['kwargs']): 5096 if key not in all_params: 5097 raise TypeError( 5098 "Got an unexpected keyword argument '%s'" 5099 " to method list_shared_access" % key 5100 ) 5101 params[key] = val 5102 del params['kwargs'] 5103 # verify the required parameter 'account_id' is set 5104 if ('account_id' not in params) or (params['account_id'] is None): 5105 raise ValueError("Missing the required parameter `account_id` when calling `list_shared_access`") 5106 5107 5108 collection_formats = {} 5109 5110 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 5111 path_params = {} 5112 if 'account_id' in params: 5113 path_params['accountId'] = params['account_id'] 5114 5115 query_params = {} 5116 if 'count' in params: 5117 query_params['count'] = params['count'] 5118 if 'envelopes_not_shared_user_status' in params: 5119 query_params['envelopes_not_shared_user_status'] = params['envelopes_not_shared_user_status'] 5120 if 'folder_ids' in params: 5121 query_params['folder_ids'] = params['folder_ids'] 5122 if 'item_type' in params: 5123 query_params['item_type'] = params['item_type'] 5124 if 'search_text' in params: 5125 query_params['search_text'] = params['search_text'] 5126 if 'shared' in params: 5127 query_params['shared'] = params['shared'] 5128 if 'start_position' in params: 5129 query_params['start_position'] = params['start_position'] 5130 if 'user_ids' in params: 5131 query_params['user_ids'] = params['user_ids'] 5132 5133 header_params = {} 5134 5135 form_params = [] 5136 local_var_files = {} 5137 5138 body_params = None 5139 # HTTP header `Accept` 5140 header_params['Accept'] = self.api_client.\ 5141 select_header_accept(['application/json']) 5142 5143 # Authentication setting 5144 auth_settings = [] 5145 5146 return self.api_client.call_api(resource_path, 'GET', 5147 path_params, 5148 query_params, 5149 header_params, 5150 body=body_params, 5151 post_params=form_params, 5152 files=local_var_files, 5153 response_type='AccountSharedAccess', 5154 auth_settings=auth_settings, 5155 callback=params.get('callback'), 5156 _return_http_data_only=params.get('_return_http_data_only'), 5157 _preload_content=params.get('_preload_content', True), 5158 _request_timeout=params.get('_request_timeout'), 5159 collection_formats=collection_formats) 5160 5161 def list_signature_providers(self, account_id, **kwargs): 5162 """ 5163 Returns Account available signature providers for specified account. 5164 Returns a list of signature providers that the specified account can use. 5165 This method makes a synchronous HTTP request by default. To make an 5166 asynchronous HTTP request, please define a `callback` function 5167 to be invoked when receiving the response. 5168 >>> def callback_function(response): 5169 >>> pprint(response) 5170 >>> 5171 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 5172 5173 :param callback function: The callback function 5174 for asynchronous request. (optional) 5175 :param str account_id: The external account number (int) or account ID Guid. (required) 5176 :return: AccountSignatureProviders 5177 If the method is called asynchronously, 5178 returns the request thread. 5179 """ 5180 kwargs['_return_http_data_only'] = True 5181 if kwargs.get('callback'): 5182 return self.list_signature_providers_with_http_info(account_id, **kwargs) 5183 else: 5184 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 5185 return data 5186 5187 def list_signature_providers_with_http_info(self, account_id, **kwargs): 5188 """ 5189 Returns Account available signature providers for specified account. 5190 Returns a list of signature providers that the specified account can use. 5191 This method makes a synchronous HTTP request by default. To make an 5192 asynchronous HTTP request, please define a `callback` function 5193 to be invoked when receiving the response. 5194 >>> def callback_function(response): 5195 >>> pprint(response) 5196 >>> 5197 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 5198 5199 :param callback function: The callback function 5200 for asynchronous request. (optional) 5201 :param str account_id: The external account number (int) or account ID Guid. (required) 5202 :return: AccountSignatureProviders 5203 If the method is called asynchronously, 5204 returns the request thread. 5205 """ 5206 5207 all_params = ['account_id'] 5208 all_params.append('callback') 5209 all_params.append('_return_http_data_only') 5210 all_params.append('_preload_content') 5211 all_params.append('_request_timeout') 5212 5213 params = locals() 5214 for key, val in iteritems(params['kwargs']): 5215 if key not in all_params: 5216 raise TypeError( 5217 "Got an unexpected keyword argument '%s'" 5218 " to method list_signature_providers" % key 5219 ) 5220 params[key] = val 5221 del params['kwargs'] 5222 # verify the required parameter 'account_id' is set 5223 if ('account_id' not in params) or (params['account_id'] is None): 5224 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 5225 5226 5227 collection_formats = {} 5228 5229 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 5230 path_params = {} 5231 if 'account_id' in params: 5232 path_params['accountId'] = params['account_id'] 5233 5234 query_params = {} 5235 5236 header_params = {} 5237 5238 form_params = [] 5239 local_var_files = {} 5240 5241 body_params = None 5242 # HTTP header `Accept` 5243 header_params['Accept'] = self.api_client.\ 5244 select_header_accept(['application/json']) 5245 5246 # Authentication setting 5247 auth_settings = [] 5248 5249 return self.api_client.call_api(resource_path, 'GET', 5250 path_params, 5251 query_params, 5252 header_params, 5253 body=body_params, 5254 post_params=form_params, 5255 files=local_var_files, 5256 response_type='AccountSignatureProviders', 5257 auth_settings=auth_settings, 5258 callback=params.get('callback'), 5259 _return_http_data_only=params.get('_return_http_data_only'), 5260 _preload_content=params.get('_preload_content', True), 5261 _request_timeout=params.get('_request_timeout'), 5262 collection_formats=collection_formats) 5263 5264 def list_unsupported_file_types(self, account_id, **kwargs): 5265 """ 5266 Gets a list of unsupported file types. 5267 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 5268 This method makes a synchronous HTTP request by default. To make an 5269 asynchronous HTTP request, please define a `callback` function 5270 to be invoked when receiving the response. 5271 >>> def callback_function(response): 5272 >>> pprint(response) 5273 >>> 5274 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 5275 5276 :param callback function: The callback function 5277 for asynchronous request. (optional) 5278 :param str account_id: The external account number (int) or account ID Guid. (required) 5279 :return: FileTypeList 5280 If the method is called asynchronously, 5281 returns the request thread. 5282 """ 5283 kwargs['_return_http_data_only'] = True 5284 if kwargs.get('callback'): 5285 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 5286 else: 5287 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 5288 return data 5289 5290 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 5291 """ 5292 Gets a list of unsupported file types. 5293 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 5294 This method makes a synchronous HTTP request by default. To make an 5295 asynchronous HTTP request, please define a `callback` function 5296 to be invoked when receiving the response. 5297 >>> def callback_function(response): 5298 >>> pprint(response) 5299 >>> 5300 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 5301 5302 :param callback function: The callback function 5303 for asynchronous request. (optional) 5304 :param str account_id: The external account number (int) or account ID Guid. (required) 5305 :return: FileTypeList 5306 If the method is called asynchronously, 5307 returns the request thread. 5308 """ 5309 5310 all_params = ['account_id'] 5311 all_params.append('callback') 5312 all_params.append('_return_http_data_only') 5313 all_params.append('_preload_content') 5314 all_params.append('_request_timeout') 5315 5316 params = locals() 5317 for key, val in iteritems(params['kwargs']): 5318 if key not in all_params: 5319 raise TypeError( 5320 "Got an unexpected keyword argument '%s'" 5321 " to method list_unsupported_file_types" % key 5322 ) 5323 params[key] = val 5324 del params['kwargs'] 5325 # verify the required parameter 'account_id' is set 5326 if ('account_id' not in params) or (params['account_id'] is None): 5327 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 5328 5329 5330 collection_formats = {} 5331 5332 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 5333 path_params = {} 5334 if 'account_id' in params: 5335 path_params['accountId'] = params['account_id'] 5336 5337 query_params = {} 5338 5339 header_params = {} 5340 5341 form_params = [] 5342 local_var_files = {} 5343 5344 body_params = None 5345 # HTTP header `Accept` 5346 header_params['Accept'] = self.api_client.\ 5347 select_header_accept(['application/json']) 5348 5349 # Authentication setting 5350 auth_settings = [] 5351 5352 return self.api_client.call_api(resource_path, 'GET', 5353 path_params, 5354 query_params, 5355 header_params, 5356 body=body_params, 5357 post_params=form_params, 5358 files=local_var_files, 5359 response_type='FileTypeList', 5360 auth_settings=auth_settings, 5361 callback=params.get('callback'), 5362 _return_http_data_only=params.get('_return_http_data_only'), 5363 _preload_content=params.get('_preload_content', True), 5364 _request_timeout=params.get('_request_timeout'), 5365 collection_formats=collection_formats) 5366 5367 def un_favorite_template(self, account_id, **kwargs): 5368 """ 5369 Unfavorite a template 5370 5371 This method makes a synchronous HTTP request by default. To make an 5372 asynchronous HTTP request, please define a `callback` function 5373 to be invoked when receiving the response. 5374 >>> def callback_function(response): 5375 >>> pprint(response) 5376 >>> 5377 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 5378 5379 :param callback function: The callback function 5380 for asynchronous request. (optional) 5381 :param str account_id: The external account number (int) or account ID Guid. (required) 5382 :param FavoriteTemplatesInfo favorite_templates_info: 5383 :return: FavoriteTemplatesInfo 5384 If the method is called asynchronously, 5385 returns the request thread. 5386 """ 5387 kwargs['_return_http_data_only'] = True 5388 if kwargs.get('callback'): 5389 return self.un_favorite_template_with_http_info(account_id, **kwargs) 5390 else: 5391 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 5392 return data 5393 5394 def un_favorite_template_with_http_info(self, account_id, **kwargs): 5395 """ 5396 Unfavorite a template 5397 5398 This method makes a synchronous HTTP request by default. To make an 5399 asynchronous HTTP request, please define a `callback` function 5400 to be invoked when receiving the response. 5401 >>> def callback_function(response): 5402 >>> pprint(response) 5403 >>> 5404 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 5405 5406 :param callback function: The callback function 5407 for asynchronous request. (optional) 5408 :param str account_id: The external account number (int) or account ID Guid. (required) 5409 :param FavoriteTemplatesInfo favorite_templates_info: 5410 :return: FavoriteTemplatesInfo 5411 If the method is called asynchronously, 5412 returns the request thread. 5413 """ 5414 5415 all_params = ['account_id', 'favorite_templates_info'] 5416 all_params.append('callback') 5417 all_params.append('_return_http_data_only') 5418 all_params.append('_preload_content') 5419 all_params.append('_request_timeout') 5420 5421 params = locals() 5422 for key, val in iteritems(params['kwargs']): 5423 if key not in all_params: 5424 raise TypeError( 5425 "Got an unexpected keyword argument '%s'" 5426 " to method un_favorite_template" % key 5427 ) 5428 params[key] = val 5429 del params['kwargs'] 5430 # verify the required parameter 'account_id' is set 5431 if ('account_id' not in params) or (params['account_id'] is None): 5432 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 5433 5434 5435 collection_formats = {} 5436 5437 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 5438 path_params = {} 5439 if 'account_id' in params: 5440 path_params['accountId'] = params['account_id'] 5441 5442 query_params = {} 5443 5444 header_params = {} 5445 5446 form_params = [] 5447 local_var_files = {} 5448 5449 body_params = None 5450 if 'favorite_templates_info' in params: 5451 body_params = params['favorite_templates_info'] 5452 # HTTP header `Accept` 5453 header_params['Accept'] = self.api_client.\ 5454 select_header_accept(['application/json']) 5455 5456 # Authentication setting 5457 auth_settings = [] 5458 5459 return self.api_client.call_api(resource_path, 'DELETE', 5460 path_params, 5461 query_params, 5462 header_params, 5463 body=body_params, 5464 post_params=form_params, 5465 files=local_var_files, 5466 response_type='FavoriteTemplatesInfo', 5467 auth_settings=auth_settings, 5468 callback=params.get('callback'), 5469 _return_http_data_only=params.get('_return_http_data_only'), 5470 _preload_content=params.get('_preload_content', True), 5471 _request_timeout=params.get('_request_timeout'), 5472 collection_formats=collection_formats) 5473 5474 def update_account_signature(self, account_id, **kwargs): 5475 """ 5476 Updates a account signature. 5477 5478 This method makes a synchronous HTTP request by default. To make an 5479 asynchronous HTTP request, please define a `callback` function 5480 to be invoked when receiving the response. 5481 >>> def callback_function(response): 5482 >>> pprint(response) 5483 >>> 5484 >>> thread = api.update_account_signature(account_id, callback=callback_function) 5485 5486 :param callback function: The callback function 5487 for asynchronous request. (optional) 5488 :param str account_id: The external account number (int) or account ID Guid. (required) 5489 :param AccountSignaturesInformation account_signatures_information: 5490 :return: AccountSignaturesInformation 5491 If the method is called asynchronously, 5492 returns the request thread. 5493 """ 5494 kwargs['_return_http_data_only'] = True 5495 if kwargs.get('callback'): 5496 return self.update_account_signature_with_http_info(account_id, **kwargs) 5497 else: 5498 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 5499 return data 5500 5501 def update_account_signature_with_http_info(self, account_id, **kwargs): 5502 """ 5503 Updates a account signature. 5504 5505 This method makes a synchronous HTTP request by default. To make an 5506 asynchronous HTTP request, please define a `callback` function 5507 to be invoked when receiving the response. 5508 >>> def callback_function(response): 5509 >>> pprint(response) 5510 >>> 5511 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 5512 5513 :param callback function: The callback function 5514 for asynchronous request. (optional) 5515 :param str account_id: The external account number (int) or account ID Guid. (required) 5516 :param AccountSignaturesInformation account_signatures_information: 5517 :return: AccountSignaturesInformation 5518 If the method is called asynchronously, 5519 returns the request thread. 5520 """ 5521 5522 all_params = ['account_id', 'account_signatures_information'] 5523 all_params.append('callback') 5524 all_params.append('_return_http_data_only') 5525 all_params.append('_preload_content') 5526 all_params.append('_request_timeout') 5527 5528 params = locals() 5529 for key, val in iteritems(params['kwargs']): 5530 if key not in all_params: 5531 raise TypeError( 5532 "Got an unexpected keyword argument '%s'" 5533 " to method update_account_signature" % key 5534 ) 5535 params[key] = val 5536 del params['kwargs'] 5537 # verify the required parameter 'account_id' is set 5538 if ('account_id' not in params) or (params['account_id'] is None): 5539 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 5540 5541 5542 collection_formats = {} 5543 5544 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 5545 path_params = {} 5546 if 'account_id' in params: 5547 path_params['accountId'] = params['account_id'] 5548 5549 query_params = {} 5550 5551 header_params = {} 5552 5553 form_params = [] 5554 local_var_files = {} 5555 5556 body_params = None 5557 if 'account_signatures_information' in params: 5558 body_params = params['account_signatures_information'] 5559 # HTTP header `Accept` 5560 header_params['Accept'] = self.api_client.\ 5561 select_header_accept(['application/json']) 5562 5563 # Authentication setting 5564 auth_settings = [] 5565 5566 return self.api_client.call_api(resource_path, 'PUT', 5567 path_params, 5568 query_params, 5569 header_params, 5570 body=body_params, 5571 post_params=form_params, 5572 files=local_var_files, 5573 response_type='AccountSignaturesInformation', 5574 auth_settings=auth_settings, 5575 callback=params.get('callback'), 5576 _return_http_data_only=params.get('_return_http_data_only'), 5577 _preload_content=params.get('_preload_content', True), 5578 _request_timeout=params.get('_request_timeout'), 5579 collection_formats=collection_formats) 5580 5581 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 5582 """ 5583 Updates a account signature. 5584 5585 This method makes a synchronous HTTP request by default. To make an 5586 asynchronous HTTP request, please define a `callback` function 5587 to be invoked when receiving the response. 5588 >>> def callback_function(response): 5589 >>> pprint(response) 5590 >>> 5591 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 5592 5593 :param callback function: The callback function 5594 for asynchronous request. (optional) 5595 :param str account_id: The external account number (int) or account ID Guid. (required) 5596 :param str signature_id: The ID of the signature being accessed. (required) 5597 :param str close_existing_signature: 5598 :param AccountSignatureDefinition account_signature_definition: 5599 :return: AccountSignature 5600 If the method is called asynchronously, 5601 returns the request thread. 5602 """ 5603 kwargs['_return_http_data_only'] = True 5604 if kwargs.get('callback'): 5605 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 5606 else: 5607 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 5608 return data 5609 5610 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 5611 """ 5612 Updates a account signature. 5613 5614 This method makes a synchronous HTTP request by default. To make an 5615 asynchronous HTTP request, please define a `callback` function 5616 to be invoked when receiving the response. 5617 >>> def callback_function(response): 5618 >>> pprint(response) 5619 >>> 5620 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 5621 5622 :param callback function: The callback function 5623 for asynchronous request. (optional) 5624 :param str account_id: The external account number (int) or account ID Guid. (required) 5625 :param str signature_id: The ID of the signature being accessed. (required) 5626 :param str close_existing_signature: 5627 :param AccountSignatureDefinition account_signature_definition: 5628 :return: AccountSignature 5629 If the method is called asynchronously, 5630 returns the request thread. 5631 """ 5632 5633 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 5634 all_params.append('callback') 5635 all_params.append('_return_http_data_only') 5636 all_params.append('_preload_content') 5637 all_params.append('_request_timeout') 5638 5639 params = locals() 5640 for key, val in iteritems(params['kwargs']): 5641 if key not in all_params: 5642 raise TypeError( 5643 "Got an unexpected keyword argument '%s'" 5644 " to method update_account_signature_by_id" % key 5645 ) 5646 params[key] = val 5647 del params['kwargs'] 5648 # verify the required parameter 'account_id' is set 5649 if ('account_id' not in params) or (params['account_id'] is None): 5650 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 5651 # verify the required parameter 'signature_id' is set 5652 if ('signature_id' not in params) or (params['signature_id'] is None): 5653 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 5654 5655 5656 collection_formats = {} 5657 5658 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 5659 path_params = {} 5660 if 'account_id' in params: 5661 path_params['accountId'] = params['account_id'] 5662 if 'signature_id' in params: 5663 path_params['signatureId'] = params['signature_id'] 5664 5665 query_params = {} 5666 if 'close_existing_signature' in params: 5667 query_params['close_existing_signature'] = params['close_existing_signature'] 5668 5669 header_params = {} 5670 5671 form_params = [] 5672 local_var_files = {} 5673 5674 body_params = None 5675 if 'account_signature_definition' in params: 5676 body_params = params['account_signature_definition'] 5677 # HTTP header `Accept` 5678 header_params['Accept'] = self.api_client.\ 5679 select_header_accept(['application/json']) 5680 5681 # Authentication setting 5682 auth_settings = [] 5683 5684 return self.api_client.call_api(resource_path, 'PUT', 5685 path_params, 5686 query_params, 5687 header_params, 5688 body=body_params, 5689 post_params=form_params, 5690 files=local_var_files, 5691 response_type='AccountSignature', 5692 auth_settings=auth_settings, 5693 callback=params.get('callback'), 5694 _return_http_data_only=params.get('_return_http_data_only'), 5695 _preload_content=params.get('_preload_content', True), 5696 _request_timeout=params.get('_request_timeout'), 5697 collection_formats=collection_formats) 5698 5699 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 5700 """ 5701 Sets a signature, initials, or stamps image. 5702 5703 This method makes a synchronous HTTP request by default. To make an 5704 asynchronous HTTP request, please define a `callback` function 5705 to be invoked when receiving the response. 5706 >>> def callback_function(response): 5707 >>> pprint(response) 5708 >>> 5709 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 5710 5711 :param callback function: The callback function 5712 for asynchronous request. (optional) 5713 :param str account_id: The external account number (int) or account ID Guid. (required) 5714 :param str image_type: One of **signature_image** or **initials_image**. (required) 5715 :param str signature_id: The ID of the signature being accessed. (required) 5716 :param str transparent_png: 5717 :return: AccountSignature 5718 If the method is called asynchronously, 5719 returns the request thread. 5720 """ 5721 kwargs['_return_http_data_only'] = True 5722 if kwargs.get('callback'): 5723 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 5724 else: 5725 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 5726 return data 5727 5728 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 5729 """ 5730 Sets a signature, initials, or stamps image. 5731 5732 This method makes a synchronous HTTP request by default. To make an 5733 asynchronous HTTP request, please define a `callback` function 5734 to be invoked when receiving the response. 5735 >>> def callback_function(response): 5736 >>> pprint(response) 5737 >>> 5738 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 5739 5740 :param callback function: The callback function 5741 for asynchronous request. (optional) 5742 :param str account_id: The external account number (int) or account ID Guid. (required) 5743 :param str image_type: One of **signature_image** or **initials_image**. (required) 5744 :param str signature_id: The ID of the signature being accessed. (required) 5745 :param str transparent_png: 5746 :return: AccountSignature 5747 If the method is called asynchronously, 5748 returns the request thread. 5749 """ 5750 5751 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 5752 all_params.append('callback') 5753 all_params.append('_return_http_data_only') 5754 all_params.append('_preload_content') 5755 all_params.append('_request_timeout') 5756 5757 params = locals() 5758 for key, val in iteritems(params['kwargs']): 5759 if key not in all_params: 5760 raise TypeError( 5761 "Got an unexpected keyword argument '%s'" 5762 " to method update_account_signature_image" % key 5763 ) 5764 params[key] = val 5765 del params['kwargs'] 5766 # verify the required parameter 'account_id' is set 5767 if ('account_id' not in params) or (params['account_id'] is None): 5768 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 5769 # verify the required parameter 'image_type' is set 5770 if ('image_type' not in params) or (params['image_type'] is None): 5771 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 5772 # verify the required parameter 'signature_id' is set 5773 if ('signature_id' not in params) or (params['signature_id'] is None): 5774 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 5775 5776 5777 collection_formats = {} 5778 5779 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 5780 path_params = {} 5781 if 'account_id' in params: 5782 path_params['accountId'] = params['account_id'] 5783 if 'image_type' in params: 5784 path_params['imageType'] = params['image_type'] 5785 if 'signature_id' in params: 5786 path_params['signatureId'] = params['signature_id'] 5787 5788 query_params = {} 5789 if 'transparent_png' in params: 5790 query_params['transparent_png'] = params['transparent_png'] 5791 5792 header_params = {} 5793 5794 form_params = [] 5795 local_var_files = {} 5796 5797 body_params = None 5798 # HTTP header `Accept` 5799 header_params['Accept'] = self.api_client.\ 5800 select_header_accept(['application/json']) 5801 5802 # HTTP header `Content-Type` 5803 header_params['Content-Type'] = self.api_client.\ 5804 select_header_content_type(['image/gif']) 5805 5806 # Authentication setting 5807 auth_settings = [] 5808 5809 return self.api_client.call_api(resource_path, 'PUT', 5810 path_params, 5811 query_params, 5812 header_params, 5813 body=body_params, 5814 post_params=form_params, 5815 files=local_var_files, 5816 response_type='AccountSignature', 5817 auth_settings=auth_settings, 5818 callback=params.get('callback'), 5819 _return_http_data_only=params.get('_return_http_data_only'), 5820 _preload_content=params.get('_preload_content', True), 5821 _request_timeout=params.get('_request_timeout'), 5822 collection_formats=collection_formats) 5823 5824 def update_account_tab_settings(self, account_id, **kwargs): 5825 """ 5826 Modifies tab settings for specified account 5827 This method modifies the tab types and tab functionality that is enabled for an account. 5828 This method makes a synchronous HTTP request by default. To make an 5829 asynchronous HTTP request, please define a `callback` function 5830 to be invoked when receiving the response. 5831 >>> def callback_function(response): 5832 >>> pprint(response) 5833 >>> 5834 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 5835 5836 :param callback function: The callback function 5837 for asynchronous request. (optional) 5838 :param str account_id: The external account number (int) or account ID Guid. (required) 5839 :param TabAccountSettings tab_account_settings: 5840 :return: TabAccountSettings 5841 If the method is called asynchronously, 5842 returns the request thread. 5843 """ 5844 kwargs['_return_http_data_only'] = True 5845 if kwargs.get('callback'): 5846 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 5847 else: 5848 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 5849 return data 5850 5851 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 5852 """ 5853 Modifies tab settings for specified account 5854 This method modifies the tab types and tab functionality that is enabled for an account. 5855 This method makes a synchronous HTTP request by default. To make an 5856 asynchronous HTTP request, please define a `callback` function 5857 to be invoked when receiving the response. 5858 >>> def callback_function(response): 5859 >>> pprint(response) 5860 >>> 5861 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 5862 5863 :param callback function: The callback function 5864 for asynchronous request. (optional) 5865 :param str account_id: The external account number (int) or account ID Guid. (required) 5866 :param TabAccountSettings tab_account_settings: 5867 :return: TabAccountSettings 5868 If the method is called asynchronously, 5869 returns the request thread. 5870 """ 5871 5872 all_params = ['account_id', 'tab_account_settings'] 5873 all_params.append('callback') 5874 all_params.append('_return_http_data_only') 5875 all_params.append('_preload_content') 5876 all_params.append('_request_timeout') 5877 5878 params = locals() 5879 for key, val in iteritems(params['kwargs']): 5880 if key not in all_params: 5881 raise TypeError( 5882 "Got an unexpected keyword argument '%s'" 5883 " to method update_account_tab_settings" % key 5884 ) 5885 params[key] = val 5886 del params['kwargs'] 5887 # verify the required parameter 'account_id' is set 5888 if ('account_id' not in params) or (params['account_id'] is None): 5889 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 5890 5891 5892 collection_formats = {} 5893 5894 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 5895 path_params = {} 5896 if 'account_id' in params: 5897 path_params['accountId'] = params['account_id'] 5898 5899 query_params = {} 5900 5901 header_params = {} 5902 5903 form_params = [] 5904 local_var_files = {} 5905 5906 body_params = None 5907 if 'tab_account_settings' in params: 5908 body_params = params['tab_account_settings'] 5909 # HTTP header `Accept` 5910 header_params['Accept'] = self.api_client.\ 5911 select_header_accept(['application/json']) 5912 5913 # Authentication setting 5914 auth_settings = [] 5915 5916 return self.api_client.call_api(resource_path, 'PUT', 5917 path_params, 5918 query_params, 5919 header_params, 5920 body=body_params, 5921 post_params=form_params, 5922 files=local_var_files, 5923 response_type='TabAccountSettings', 5924 auth_settings=auth_settings, 5925 callback=params.get('callback'), 5926 _return_http_data_only=params.get('_return_http_data_only'), 5927 _preload_content=params.get('_preload_content', True), 5928 _request_timeout=params.get('_request_timeout'), 5929 collection_formats=collection_formats) 5930 5931 def update_brand(self, account_id, brand_id, **kwargs): 5932 """ 5933 Updates an existing brand. 5934 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 5935 This method makes a synchronous HTTP request by default. To make an 5936 asynchronous HTTP request, please define a `callback` function 5937 to be invoked when receiving the response. 5938 >>> def callback_function(response): 5939 >>> pprint(response) 5940 >>> 5941 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 5942 5943 :param callback function: The callback function 5944 for asynchronous request. (optional) 5945 :param str account_id: The external account number (int) or account ID Guid. (required) 5946 :param str brand_id: The unique identifier of a brand. (required) 5947 :param str replace_brand: 5948 :param Brand brand: 5949 :return: Brand 5950 If the method is called asynchronously, 5951 returns the request thread. 5952 """ 5953 kwargs['_return_http_data_only'] = True 5954 if kwargs.get('callback'): 5955 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 5956 else: 5957 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 5958 return data 5959 5960 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 5961 """ 5962 Updates an existing brand. 5963 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 5964 This method makes a synchronous HTTP request by default. To make an 5965 asynchronous HTTP request, please define a `callback` function 5966 to be invoked when receiving the response. 5967 >>> def callback_function(response): 5968 >>> pprint(response) 5969 >>> 5970 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 5971 5972 :param callback function: The callback function 5973 for asynchronous request. (optional) 5974 :param str account_id: The external account number (int) or account ID Guid. (required) 5975 :param str brand_id: The unique identifier of a brand. (required) 5976 :param str replace_brand: 5977 :param Brand brand: 5978 :return: Brand 5979 If the method is called asynchronously, 5980 returns the request thread. 5981 """ 5982 5983 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 5984 all_params.append('callback') 5985 all_params.append('_return_http_data_only') 5986 all_params.append('_preload_content') 5987 all_params.append('_request_timeout') 5988 5989 params = locals() 5990 for key, val in iteritems(params['kwargs']): 5991 if key not in all_params: 5992 raise TypeError( 5993 "Got an unexpected keyword argument '%s'" 5994 " to method update_brand" % key 5995 ) 5996 params[key] = val 5997 del params['kwargs'] 5998 # verify the required parameter 'account_id' is set 5999 if ('account_id' not in params) or (params['account_id'] is None): 6000 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6001 # verify the required parameter 'brand_id' is set 6002 if ('brand_id' not in params) or (params['brand_id'] is None): 6003 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6004 6005 6006 collection_formats = {} 6007 6008 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6009 path_params = {} 6010 if 'account_id' in params: 6011 path_params['accountId'] = params['account_id'] 6012 if 'brand_id' in params: 6013 path_params['brandId'] = params['brand_id'] 6014 6015 query_params = {} 6016 if 'replace_brand' in params: 6017 query_params['replace_brand'] = params['replace_brand'] 6018 6019 header_params = {} 6020 6021 form_params = [] 6022 local_var_files = {} 6023 6024 body_params = None 6025 if 'brand' in params: 6026 body_params = params['brand'] 6027 # HTTP header `Accept` 6028 header_params['Accept'] = self.api_client.\ 6029 select_header_accept(['application/json']) 6030 6031 # Authentication setting 6032 auth_settings = [] 6033 6034 return self.api_client.call_api(resource_path, 'PUT', 6035 path_params, 6036 query_params, 6037 header_params, 6038 body=body_params, 6039 post_params=form_params, 6040 files=local_var_files, 6041 response_type='Brand', 6042 auth_settings=auth_settings, 6043 callback=params.get('callback'), 6044 _return_http_data_only=params.get('_return_http_data_only'), 6045 _preload_content=params.get('_preload_content', True), 6046 _request_timeout=params.get('_request_timeout'), 6047 collection_formats=collection_formats) 6048 6049 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6050 """ 6051 Put one branding logo. 6052 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6053 This method makes a synchronous HTTP request by default. To make an 6054 asynchronous HTTP request, please define a `callback` function 6055 to be invoked when receiving the response. 6056 >>> def callback_function(response): 6057 >>> pprint(response) 6058 >>> 6059 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6060 6061 :param callback function: The callback function 6062 for asynchronous request. (optional) 6063 :param str account_id: The external account number (int) or account ID GUID. (required) 6064 :param str brand_id: The ID of the brand. (required) 6065 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6066 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6067 :return: None 6068 If the method is called asynchronously, 6069 returns the request thread. 6070 """ 6071 kwargs['_return_http_data_only'] = True 6072 if kwargs.get('callback'): 6073 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6074 else: 6075 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6076 return data 6077 6078 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6079 """ 6080 Put one branding logo. 6081 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6082 This method makes a synchronous HTTP request by default. To make an 6083 asynchronous HTTP request, please define a `callback` function 6084 to be invoked when receiving the response. 6085 >>> def callback_function(response): 6086 >>> pprint(response) 6087 >>> 6088 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6089 6090 :param callback function: The callback function 6091 for asynchronous request. (optional) 6092 :param str account_id: The external account number (int) or account ID GUID. (required) 6093 :param str brand_id: The ID of the brand. (required) 6094 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6095 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6096 :return: None 6097 If the method is called asynchronously, 6098 returns the request thread. 6099 """ 6100 6101 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6102 all_params.append('callback') 6103 all_params.append('_return_http_data_only') 6104 all_params.append('_preload_content') 6105 all_params.append('_request_timeout') 6106 6107 params = locals() 6108 for key, val in iteritems(params['kwargs']): 6109 if key not in all_params: 6110 raise TypeError( 6111 "Got an unexpected keyword argument '%s'" 6112 " to method update_brand_logo_by_type" % key 6113 ) 6114 params[key] = val 6115 del params['kwargs'] 6116 # verify the required parameter 'account_id' is set 6117 if ('account_id' not in params) or (params['account_id'] is None): 6118 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6119 # verify the required parameter 'brand_id' is set 6120 if ('brand_id' not in params) or (params['brand_id'] is None): 6121 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6122 # verify the required parameter 'logo_type' is set 6123 if ('logo_type' not in params) or (params['logo_type'] is None): 6124 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6125 # verify the required parameter 'logo_file_bytes' is set 6126 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6127 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6128 6129 6130 collection_formats = {} 6131 6132 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6133 path_params = {} 6134 if 'account_id' in params: 6135 path_params['accountId'] = params['account_id'] 6136 if 'brand_id' in params: 6137 path_params['brandId'] = params['brand_id'] 6138 if 'logo_type' in params: 6139 path_params['logoType'] = params['logo_type'] 6140 6141 query_params = {} 6142 6143 header_params = {} 6144 6145 form_params = [] 6146 local_var_files = {} 6147 6148 body_params = None 6149 if 'logo_file_bytes' in params: 6150 body_params = params['logo_file_bytes'] 6151 # HTTP header `Accept` 6152 header_params['Accept'] = self.api_client.\ 6153 select_header_accept(['application/json']) 6154 6155 # HTTP header `Content-Type` 6156 header_params['Content-Type'] = self.api_client.\ 6157 select_header_content_type(['image/png']) 6158 6159 # Authentication setting 6160 auth_settings = [] 6161 6162 return self.api_client.call_api(resource_path, 'PUT', 6163 path_params, 6164 query_params, 6165 header_params, 6166 body=body_params, 6167 post_params=form_params, 6168 files=local_var_files, 6169 response_type=None, 6170 auth_settings=auth_settings, 6171 callback=params.get('callback'), 6172 _return_http_data_only=params.get('_return_http_data_only'), 6173 _preload_content=params.get('_preload_content', True), 6174 _request_timeout=params.get('_request_timeout'), 6175 collection_formats=collection_formats) 6176 6177 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 6178 """ 6179 Uploads a branding resource file. 6180 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 6181 This method makes a synchronous HTTP request by default. To make an 6182 asynchronous HTTP request, please define a `callback` function 6183 to be invoked when receiving the response. 6184 >>> def callback_function(response): 6185 >>> pprint(response) 6186 >>> 6187 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 6188 6189 :param callback function: The callback function 6190 for asynchronous request. (optional) 6191 :param str account_id: The external account number (int) or account ID GUID. (required) 6192 :param str brand_id: The ID of the brand. (required) 6193 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 6194 :param file file_xml: Brand resource XML file. (required) 6195 :return: BrandResources 6196 If the method is called asynchronously, 6197 returns the request thread. 6198 """ 6199 kwargs['_return_http_data_only'] = True 6200 if kwargs.get('callback'): 6201 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 6202 else: 6203 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 6204 return data 6205 6206 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 6207 """ 6208 Uploads a branding resource file. 6209 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 6210 This method makes a synchronous HTTP request by default. To make an 6211 asynchronous HTTP request, please define a `callback` function 6212 to be invoked when receiving the response. 6213 >>> def callback_function(response): 6214 >>> pprint(response) 6215 >>> 6216 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 6217 6218 :param callback function: The callback function 6219 for asynchronous request. (optional) 6220 :param str account_id: The external account number (int) or account ID GUID. (required) 6221 :param str brand_id: The ID of the brand. (required) 6222 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 6223 :param file file_xml: Brand resource XML file. (required) 6224 :return: BrandResources 6225 If the method is called asynchronously, 6226 returns the request thread. 6227 """ 6228 6229 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 6230 all_params.append('callback') 6231 all_params.append('_return_http_data_only') 6232 all_params.append('_preload_content') 6233 all_params.append('_request_timeout') 6234 6235 params = locals() 6236 for key, val in iteritems(params['kwargs']): 6237 if key not in all_params: 6238 raise TypeError( 6239 "Got an unexpected keyword argument '%s'" 6240 " to method update_brand_resources_by_content_type" % key 6241 ) 6242 params[key] = val 6243 del params['kwargs'] 6244 # verify the required parameter 'account_id' is set 6245 if ('account_id' not in params) or (params['account_id'] is None): 6246 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 6247 # verify the required parameter 'brand_id' is set 6248 if ('brand_id' not in params) or (params['brand_id'] is None): 6249 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 6250 # verify the required parameter 'resource_content_type' is set 6251 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 6252 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 6253 # verify the required parameter 'file_xml' is set 6254 if ('file_xml' not in params) or (params['file_xml'] is None): 6255 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 6256 6257 6258 collection_formats = {} 6259 6260 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 6261 path_params = {} 6262 if 'account_id' in params: 6263 path_params['accountId'] = params['account_id'] 6264 if 'brand_id' in params: 6265 path_params['brandId'] = params['brand_id'] 6266 if 'resource_content_type' in params: 6267 path_params['resourceContentType'] = params['resource_content_type'] 6268 6269 query_params = {} 6270 6271 header_params = {} 6272 6273 form_params = [] 6274 local_var_files = {} 6275 if 'file_xml' in params: 6276 local_var_files['file.xml'] = params['file_xml'] 6277 6278 body_params = None 6279 # HTTP header `Accept` 6280 header_params['Accept'] = self.api_client.\ 6281 select_header_accept(['application/json']) 6282 6283 # HTTP header `Content-Type` 6284 header_params['Content-Type'] = self.api_client.\ 6285 select_header_content_type(['multipart/form-data']) 6286 6287 # Authentication setting 6288 auth_settings = [] 6289 6290 return self.api_client.call_api(resource_path, 'PUT', 6291 path_params, 6292 query_params, 6293 header_params, 6294 body=body_params, 6295 post_params=form_params, 6296 files=local_var_files, 6297 response_type='BrandResources', 6298 auth_settings=auth_settings, 6299 callback=params.get('callback'), 6300 _return_http_data_only=params.get('_return_http_data_only'), 6301 _preload_content=params.get('_preload_content', True), 6302 _request_timeout=params.get('_request_timeout'), 6303 collection_formats=collection_formats) 6304 6305 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 6306 """ 6307 Update Consumer Disclosure. 6308 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 6309 This method makes a synchronous HTTP request by default. To make an 6310 asynchronous HTTP request, please define a `callback` function 6311 to be invoked when receiving the response. 6312 >>> def callback_function(response): 6313 >>> pprint(response) 6314 >>> 6315 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 6316 6317 :param callback function: The callback function 6318 for asynchronous request. (optional) 6319 :param str account_id: The external account number (int) or account ID Guid. (required) 6320 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6321 :param str include_metadata: 6322 :param ConsumerDisclosure consumer_disclosure: 6323 :return: ConsumerDisclosure 6324 If the method is called asynchronously, 6325 returns the request thread. 6326 """ 6327 kwargs['_return_http_data_only'] = True 6328 if kwargs.get('callback'): 6329 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 6330 else: 6331 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 6332 return data 6333 6334 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 6335 """ 6336 Update Consumer Disclosure. 6337 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 6338 This method makes a synchronous HTTP request by default. To make an 6339 asynchronous HTTP request, please define a `callback` function 6340 to be invoked when receiving the response. 6341 >>> def callback_function(response): 6342 >>> pprint(response) 6343 >>> 6344 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 6345 6346 :param callback function: The callback function 6347 for asynchronous request. (optional) 6348 :param str account_id: The external account number (int) or account ID Guid. (required) 6349 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6350 :param str include_metadata: 6351 :param ConsumerDisclosure consumer_disclosure: 6352 :return: ConsumerDisclosure 6353 If the method is called asynchronously, 6354 returns the request thread. 6355 """ 6356 6357 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 6358 all_params.append('callback') 6359 all_params.append('_return_http_data_only') 6360 all_params.append('_preload_content') 6361 all_params.append('_request_timeout') 6362 6363 params = locals() 6364 for key, val in iteritems(params['kwargs']): 6365 if key not in all_params: 6366 raise TypeError( 6367 "Got an unexpected keyword argument '%s'" 6368 " to method update_consumer_disclosure" % key 6369 ) 6370 params[key] = val 6371 del params['kwargs'] 6372 # verify the required parameter 'account_id' is set 6373 if ('account_id' not in params) or (params['account_id'] is None): 6374 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 6375 # verify the required parameter 'lang_code' is set 6376 if ('lang_code' not in params) or (params['lang_code'] is None): 6377 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 6378 6379 6380 collection_formats = {} 6381 6382 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6383 path_params = {} 6384 if 'account_id' in params: 6385 path_params['accountId'] = params['account_id'] 6386 if 'lang_code' in params: 6387 path_params['langCode'] = params['lang_code'] 6388 6389 query_params = {} 6390 if 'include_metadata' in params: 6391 query_params['include_metadata'] = params['include_metadata'] 6392 6393 header_params = {} 6394 6395 form_params = [] 6396 local_var_files = {} 6397 6398 body_params = None 6399 if 'consumer_disclosure' in params: 6400 body_params = params['consumer_disclosure'] 6401 # HTTP header `Accept` 6402 header_params['Accept'] = self.api_client.\ 6403 select_header_accept(['application/json']) 6404 6405 # Authentication setting 6406 auth_settings = [] 6407 6408 return self.api_client.call_api(resource_path, 'PUT', 6409 path_params, 6410 query_params, 6411 header_params, 6412 body=body_params, 6413 post_params=form_params, 6414 files=local_var_files, 6415 response_type='ConsumerDisclosure', 6416 auth_settings=auth_settings, 6417 callback=params.get('callback'), 6418 _return_http_data_only=params.get('_return_http_data_only'), 6419 _preload_content=params.get('_preload_content', True), 6420 _request_timeout=params.get('_request_timeout'), 6421 collection_formats=collection_formats) 6422 6423 def update_custom_field(self, account_id, custom_field_id, **kwargs): 6424 """ 6425 Updates an existing account custom field. 6426 This method updates an existing account custom field. 6427 This method makes a synchronous HTTP request by default. To make an 6428 asynchronous HTTP request, please define a `callback` function 6429 to be invoked when receiving the response. 6430 >>> def callback_function(response): 6431 >>> pprint(response) 6432 >>> 6433 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 6434 6435 :param callback function: The callback function 6436 for asynchronous request. (optional) 6437 :param str account_id: The external account number (int) or account ID Guid. (required) 6438 :param str custom_field_id: (required) 6439 :param str apply_to_templates: 6440 :param CustomField custom_field: 6441 :return: CustomFields 6442 If the method is called asynchronously, 6443 returns the request thread. 6444 """ 6445 kwargs['_return_http_data_only'] = True 6446 if kwargs.get('callback'): 6447 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 6448 else: 6449 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 6450 return data 6451 6452 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 6453 """ 6454 Updates an existing account custom field. 6455 This method updates an existing account custom field. 6456 This method makes a synchronous HTTP request by default. To make an 6457 asynchronous HTTP request, please define a `callback` function 6458 to be invoked when receiving the response. 6459 >>> def callback_function(response): 6460 >>> pprint(response) 6461 >>> 6462 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 6463 6464 :param callback function: The callback function 6465 for asynchronous request. (optional) 6466 :param str account_id: The external account number (int) or account ID Guid. (required) 6467 :param str custom_field_id: (required) 6468 :param str apply_to_templates: 6469 :param CustomField custom_field: 6470 :return: CustomFields 6471 If the method is called asynchronously, 6472 returns the request thread. 6473 """ 6474 6475 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 6476 all_params.append('callback') 6477 all_params.append('_return_http_data_only') 6478 all_params.append('_preload_content') 6479 all_params.append('_request_timeout') 6480 6481 params = locals() 6482 for key, val in iteritems(params['kwargs']): 6483 if key not in all_params: 6484 raise TypeError( 6485 "Got an unexpected keyword argument '%s'" 6486 " to method update_custom_field" % key 6487 ) 6488 params[key] = val 6489 del params['kwargs'] 6490 # verify the required parameter 'account_id' is set 6491 if ('account_id' not in params) or (params['account_id'] is None): 6492 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 6493 # verify the required parameter 'custom_field_id' is set 6494 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 6495 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 6496 6497 6498 collection_formats = {} 6499 6500 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 6501 path_params = {} 6502 if 'account_id' in params: 6503 path_params['accountId'] = params['account_id'] 6504 if 'custom_field_id' in params: 6505 path_params['customFieldId'] = params['custom_field_id'] 6506 6507 query_params = {} 6508 if 'apply_to_templates' in params: 6509 query_params['apply_to_templates'] = params['apply_to_templates'] 6510 6511 header_params = {} 6512 6513 form_params = [] 6514 local_var_files = {} 6515 6516 body_params = None 6517 if 'custom_field' in params: 6518 body_params = params['custom_field'] 6519 # HTTP header `Accept` 6520 header_params['Accept'] = self.api_client.\ 6521 select_header_accept(['application/json']) 6522 6523 # Authentication setting 6524 auth_settings = [] 6525 6526 return self.api_client.call_api(resource_path, 'PUT', 6527 path_params, 6528 query_params, 6529 header_params, 6530 body=body_params, 6531 post_params=form_params, 6532 files=local_var_files, 6533 response_type='CustomFields', 6534 auth_settings=auth_settings, 6535 callback=params.get('callback'), 6536 _return_http_data_only=params.get('_return_http_data_only'), 6537 _preload_content=params.get('_preload_content', True), 6538 _request_timeout=params.get('_request_timeout'), 6539 collection_formats=collection_formats) 6540 6541 def update_e_note_configuration(self, account_id, **kwargs): 6542 """ 6543 Updates configuration information for the eNote eOriginal integration. 6544 6545 This method makes a synchronous HTTP request by default. To make an 6546 asynchronous HTTP request, please define a `callback` function 6547 to be invoked when receiving the response. 6548 >>> def callback_function(response): 6549 >>> pprint(response) 6550 >>> 6551 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 6552 6553 :param callback function: The callback function 6554 for asynchronous request. (optional) 6555 :param str account_id: The external account number (int) or account ID Guid. (required) 6556 :param ENoteConfiguration e_note_configuration: 6557 :return: ENoteConfiguration 6558 If the method is called asynchronously, 6559 returns the request thread. 6560 """ 6561 kwargs['_return_http_data_only'] = True 6562 if kwargs.get('callback'): 6563 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 6564 else: 6565 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 6566 return data 6567 6568 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 6569 """ 6570 Updates configuration information for the eNote eOriginal integration. 6571 6572 This method makes a synchronous HTTP request by default. To make an 6573 asynchronous HTTP request, please define a `callback` function 6574 to be invoked when receiving the response. 6575 >>> def callback_function(response): 6576 >>> pprint(response) 6577 >>> 6578 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 6579 6580 :param callback function: The callback function 6581 for asynchronous request. (optional) 6582 :param str account_id: The external account number (int) or account ID Guid. (required) 6583 :param ENoteConfiguration e_note_configuration: 6584 :return: ENoteConfiguration 6585 If the method is called asynchronously, 6586 returns the request thread. 6587 """ 6588 6589 all_params = ['account_id', 'e_note_configuration'] 6590 all_params.append('callback') 6591 all_params.append('_return_http_data_only') 6592 all_params.append('_preload_content') 6593 all_params.append('_request_timeout') 6594 6595 params = locals() 6596 for key, val in iteritems(params['kwargs']): 6597 if key not in all_params: 6598 raise TypeError( 6599 "Got an unexpected keyword argument '%s'" 6600 " to method update_e_note_configuration" % key 6601 ) 6602 params[key] = val 6603 del params['kwargs'] 6604 # verify the required parameter 'account_id' is set 6605 if ('account_id' not in params) or (params['account_id'] is None): 6606 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 6607 6608 6609 collection_formats = {} 6610 6611 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 6612 path_params = {} 6613 if 'account_id' in params: 6614 path_params['accountId'] = params['account_id'] 6615 6616 query_params = {} 6617 6618 header_params = {} 6619 6620 form_params = [] 6621 local_var_files = {} 6622 6623 body_params = None 6624 if 'e_note_configuration' in params: 6625 body_params = params['e_note_configuration'] 6626 # HTTP header `Accept` 6627 header_params['Accept'] = self.api_client.\ 6628 select_header_accept(['application/json']) 6629 6630 # Authentication setting 6631 auth_settings = [] 6632 6633 return self.api_client.call_api(resource_path, 'PUT', 6634 path_params, 6635 query_params, 6636 header_params, 6637 body=body_params, 6638 post_params=form_params, 6639 files=local_var_files, 6640 response_type='ENoteConfiguration', 6641 auth_settings=auth_settings, 6642 callback=params.get('callback'), 6643 _return_http_data_only=params.get('_return_http_data_only'), 6644 _preload_content=params.get('_preload_content', True), 6645 _request_timeout=params.get('_request_timeout'), 6646 collection_formats=collection_formats) 6647 6648 def update_envelope_purge_configuration(self, account_id, **kwargs): 6649 """ 6650 Updates envelope purge configuration. 6651 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 6652 This method makes a synchronous HTTP request by default. To make an 6653 asynchronous HTTP request, please define a `callback` function 6654 to be invoked when receiving the response. 6655 >>> def callback_function(response): 6656 >>> pprint(response) 6657 >>> 6658 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 6659 6660 :param callback function: The callback function 6661 for asynchronous request. (optional) 6662 :param str account_id: The external account number (int) or account ID Guid. (required) 6663 :param EnvelopePurgeConfiguration envelope_purge_configuration: 6664 :return: EnvelopePurgeConfiguration 6665 If the method is called asynchronously, 6666 returns the request thread. 6667 """ 6668 kwargs['_return_http_data_only'] = True 6669 if kwargs.get('callback'): 6670 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 6671 else: 6672 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 6673 return data 6674 6675 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 6676 """ 6677 Updates envelope purge configuration. 6678 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 6679 This method makes a synchronous HTTP request by default. To make an 6680 asynchronous HTTP request, please define a `callback` function 6681 to be invoked when receiving the response. 6682 >>> def callback_function(response): 6683 >>> pprint(response) 6684 >>> 6685 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 6686 6687 :param callback function: The callback function 6688 for asynchronous request. (optional) 6689 :param str account_id: The external account number (int) or account ID Guid. (required) 6690 :param EnvelopePurgeConfiguration envelope_purge_configuration: 6691 :return: EnvelopePurgeConfiguration 6692 If the method is called asynchronously, 6693 returns the request thread. 6694 """ 6695 6696 all_params = ['account_id', 'envelope_purge_configuration'] 6697 all_params.append('callback') 6698 all_params.append('_return_http_data_only') 6699 all_params.append('_preload_content') 6700 all_params.append('_request_timeout') 6701 6702 params = locals() 6703 for key, val in iteritems(params['kwargs']): 6704 if key not in all_params: 6705 raise TypeError( 6706 "Got an unexpected keyword argument '%s'" 6707 " to method update_envelope_purge_configuration" % key 6708 ) 6709 params[key] = val 6710 del params['kwargs'] 6711 # verify the required parameter 'account_id' is set 6712 if ('account_id' not in params) or (params['account_id'] is None): 6713 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 6714 6715 6716 collection_formats = {} 6717 6718 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 6719 path_params = {} 6720 if 'account_id' in params: 6721 path_params['accountId'] = params['account_id'] 6722 6723 query_params = {} 6724 6725 header_params = {} 6726 6727 form_params = [] 6728 local_var_files = {} 6729 6730 body_params = None 6731 if 'envelope_purge_configuration' in params: 6732 body_params = params['envelope_purge_configuration'] 6733 # HTTP header `Accept` 6734 header_params['Accept'] = self.api_client.\ 6735 select_header_accept(['application/json']) 6736 6737 # Authentication setting 6738 auth_settings = [] 6739 6740 return self.api_client.call_api(resource_path, 'PUT', 6741 path_params, 6742 query_params, 6743 header_params, 6744 body=body_params, 6745 post_params=form_params, 6746 files=local_var_files, 6747 response_type='EnvelopePurgeConfiguration', 6748 auth_settings=auth_settings, 6749 callback=params.get('callback'), 6750 _return_http_data_only=params.get('_return_http_data_only'), 6751 _preload_content=params.get('_preload_content', True), 6752 _request_timeout=params.get('_request_timeout'), 6753 collection_formats=collection_formats) 6754 6755 def update_favorite_template(self, account_id, **kwargs): 6756 """ 6757 Favorites a template 6758 6759 This method makes a synchronous HTTP request by default. To make an 6760 asynchronous HTTP request, please define a `callback` function 6761 to be invoked when receiving the response. 6762 >>> def callback_function(response): 6763 >>> pprint(response) 6764 >>> 6765 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 6766 6767 :param callback function: The callback function 6768 for asynchronous request. (optional) 6769 :param str account_id: The external account number (int) or account ID Guid. (required) 6770 :param FavoriteTemplatesInfo favorite_templates_info: 6771 :return: FavoriteTemplatesInfo 6772 If the method is called asynchronously, 6773 returns the request thread. 6774 """ 6775 kwargs['_return_http_data_only'] = True 6776 if kwargs.get('callback'): 6777 return self.update_favorite_template_with_http_info(account_id, **kwargs) 6778 else: 6779 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 6780 return data 6781 6782 def update_favorite_template_with_http_info(self, account_id, **kwargs): 6783 """ 6784 Favorites a template 6785 6786 This method makes a synchronous HTTP request by default. To make an 6787 asynchronous HTTP request, please define a `callback` function 6788 to be invoked when receiving the response. 6789 >>> def callback_function(response): 6790 >>> pprint(response) 6791 >>> 6792 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 6793 6794 :param callback function: The callback function 6795 for asynchronous request. (optional) 6796 :param str account_id: The external account number (int) or account ID Guid. (required) 6797 :param FavoriteTemplatesInfo favorite_templates_info: 6798 :return: FavoriteTemplatesInfo 6799 If the method is called asynchronously, 6800 returns the request thread. 6801 """ 6802 6803 all_params = ['account_id', 'favorite_templates_info'] 6804 all_params.append('callback') 6805 all_params.append('_return_http_data_only') 6806 all_params.append('_preload_content') 6807 all_params.append('_request_timeout') 6808 6809 params = locals() 6810 for key, val in iteritems(params['kwargs']): 6811 if key not in all_params: 6812 raise TypeError( 6813 "Got an unexpected keyword argument '%s'" 6814 " to method update_favorite_template" % key 6815 ) 6816 params[key] = val 6817 del params['kwargs'] 6818 # verify the required parameter 'account_id' is set 6819 if ('account_id' not in params) or (params['account_id'] is None): 6820 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 6821 6822 6823 collection_formats = {} 6824 6825 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6826 path_params = {} 6827 if 'account_id' in params: 6828 path_params['accountId'] = params['account_id'] 6829 6830 query_params = {} 6831 6832 header_params = {} 6833 6834 form_params = [] 6835 local_var_files = {} 6836 6837 body_params = None 6838 if 'favorite_templates_info' in params: 6839 body_params = params['favorite_templates_info'] 6840 # HTTP header `Accept` 6841 header_params['Accept'] = self.api_client.\ 6842 select_header_accept(['application/json']) 6843 6844 # Authentication setting 6845 auth_settings = [] 6846 6847 return self.api_client.call_api(resource_path, 'PUT', 6848 path_params, 6849 query_params, 6850 header_params, 6851 body=body_params, 6852 post_params=form_params, 6853 files=local_var_files, 6854 response_type='FavoriteTemplatesInfo', 6855 auth_settings=auth_settings, 6856 callback=params.get('callback'), 6857 _return_http_data_only=params.get('_return_http_data_only'), 6858 _preload_content=params.get('_preload_content', True), 6859 _request_timeout=params.get('_request_timeout'), 6860 collection_formats=collection_formats) 6861 6862 def update_notification_defaults(self, account_id, **kwargs): 6863 """ 6864 Updates default user level settings for a specified account 6865 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 6866 This method makes a synchronous HTTP request by default. To make an 6867 asynchronous HTTP request, please define a `callback` function 6868 to be invoked when receiving the response. 6869 >>> def callback_function(response): 6870 >>> pprint(response) 6871 >>> 6872 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 6873 6874 :param callback function: The callback function 6875 for asynchronous request. (optional) 6876 :param str account_id: The external account number (int) or account ID Guid. (required) 6877 :param NotificationDefaults notification_defaults: 6878 :return: NotificationDefaults 6879 If the method is called asynchronously, 6880 returns the request thread. 6881 """ 6882 kwargs['_return_http_data_only'] = True 6883 if kwargs.get('callback'): 6884 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 6885 else: 6886 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 6887 return data 6888 6889 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 6890 """ 6891 Updates default user level settings for a specified account 6892 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 6893 This method makes a synchronous HTTP request by default. To make an 6894 asynchronous HTTP request, please define a `callback` function 6895 to be invoked when receiving the response. 6896 >>> def callback_function(response): 6897 >>> pprint(response) 6898 >>> 6899 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 6900 6901 :param callback function: The callback function 6902 for asynchronous request. (optional) 6903 :param str account_id: The external account number (int) or account ID Guid. (required) 6904 :param NotificationDefaults notification_defaults: 6905 :return: NotificationDefaults 6906 If the method is called asynchronously, 6907 returns the request thread. 6908 """ 6909 6910 all_params = ['account_id', 'notification_defaults'] 6911 all_params.append('callback') 6912 all_params.append('_return_http_data_only') 6913 all_params.append('_preload_content') 6914 all_params.append('_request_timeout') 6915 6916 params = locals() 6917 for key, val in iteritems(params['kwargs']): 6918 if key not in all_params: 6919 raise TypeError( 6920 "Got an unexpected keyword argument '%s'" 6921 " to method update_notification_defaults" % key 6922 ) 6923 params[key] = val 6924 del params['kwargs'] 6925 # verify the required parameter 'account_id' is set 6926 if ('account_id' not in params) or (params['account_id'] is None): 6927 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 6928 6929 6930 collection_formats = {} 6931 6932 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 6933 path_params = {} 6934 if 'account_id' in params: 6935 path_params['accountId'] = params['account_id'] 6936 6937 query_params = {} 6938 6939 header_params = {} 6940 6941 form_params = [] 6942 local_var_files = {} 6943 6944 body_params = None 6945 if 'notification_defaults' in params: 6946 body_params = params['notification_defaults'] 6947 # HTTP header `Accept` 6948 header_params['Accept'] = self.api_client.\ 6949 select_header_accept(['application/json']) 6950 6951 # Authentication setting 6952 auth_settings = [] 6953 6954 return self.api_client.call_api(resource_path, 'PUT', 6955 path_params, 6956 query_params, 6957 header_params, 6958 body=body_params, 6959 post_params=form_params, 6960 files=local_var_files, 6961 response_type='NotificationDefaults', 6962 auth_settings=auth_settings, 6963 callback=params.get('callback'), 6964 _return_http_data_only=params.get('_return_http_data_only'), 6965 _preload_content=params.get('_preload_content', True), 6966 _request_timeout=params.get('_request_timeout'), 6967 collection_formats=collection_formats) 6968 6969 def update_password_rules(self, account_id, **kwargs): 6970 """ 6971 Update the password rules 6972 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 6973 This method makes a synchronous HTTP request by default. To make an 6974 asynchronous HTTP request, please define a `callback` function 6975 to be invoked when receiving the response. 6976 >>> def callback_function(response): 6977 >>> pprint(response) 6978 >>> 6979 >>> thread = api.update_password_rules(account_id, callback=callback_function) 6980 6981 :param callback function: The callback function 6982 for asynchronous request. (optional) 6983 :param str account_id: The external account number (int) or account ID Guid. (required) 6984 :param AccountPasswordRules account_password_rules: 6985 :return: AccountPasswordRules 6986 If the method is called asynchronously, 6987 returns the request thread. 6988 """ 6989 kwargs['_return_http_data_only'] = True 6990 if kwargs.get('callback'): 6991 return self.update_password_rules_with_http_info(account_id, **kwargs) 6992 else: 6993 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 6994 return data 6995 6996 def update_password_rules_with_http_info(self, account_id, **kwargs): 6997 """ 6998 Update the password rules 6999 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7000 This method makes a synchronous HTTP request by default. To make an 7001 asynchronous HTTP request, please define a `callback` function 7002 to be invoked when receiving the response. 7003 >>> def callback_function(response): 7004 >>> pprint(response) 7005 >>> 7006 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7007 7008 :param callback function: The callback function 7009 for asynchronous request. (optional) 7010 :param str account_id: The external account number (int) or account ID Guid. (required) 7011 :param AccountPasswordRules account_password_rules: 7012 :return: AccountPasswordRules 7013 If the method is called asynchronously, 7014 returns the request thread. 7015 """ 7016 7017 all_params = ['account_id', 'account_password_rules'] 7018 all_params.append('callback') 7019 all_params.append('_return_http_data_only') 7020 all_params.append('_preload_content') 7021 all_params.append('_request_timeout') 7022 7023 params = locals() 7024 for key, val in iteritems(params['kwargs']): 7025 if key not in all_params: 7026 raise TypeError( 7027 "Got an unexpected keyword argument '%s'" 7028 " to method update_password_rules" % key 7029 ) 7030 params[key] = val 7031 del params['kwargs'] 7032 # verify the required parameter 'account_id' is set 7033 if ('account_id' not in params) or (params['account_id'] is None): 7034 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7035 7036 7037 collection_formats = {} 7038 7039 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7040 path_params = {} 7041 if 'account_id' in params: 7042 path_params['accountId'] = params['account_id'] 7043 7044 query_params = {} 7045 7046 header_params = {} 7047 7048 form_params = [] 7049 local_var_files = {} 7050 7051 body_params = None 7052 if 'account_password_rules' in params: 7053 body_params = params['account_password_rules'] 7054 # HTTP header `Accept` 7055 header_params['Accept'] = self.api_client.\ 7056 select_header_accept(['application/json']) 7057 7058 # Authentication setting 7059 auth_settings = [] 7060 7061 return self.api_client.call_api(resource_path, 'PUT', 7062 path_params, 7063 query_params, 7064 header_params, 7065 body=body_params, 7066 post_params=form_params, 7067 files=local_var_files, 7068 response_type='AccountPasswordRules', 7069 auth_settings=auth_settings, 7070 callback=params.get('callback'), 7071 _return_http_data_only=params.get('_return_http_data_only'), 7072 _preload_content=params.get('_preload_content', True), 7073 _request_timeout=params.get('_request_timeout'), 7074 collection_formats=collection_formats) 7075 7076 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7077 """ 7078 Updates a permission profile within the specified account. 7079 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7080 This method makes a synchronous HTTP request by default. To make an 7081 asynchronous HTTP request, please define a `callback` function 7082 to be invoked when receiving the response. 7083 >>> def callback_function(response): 7084 >>> pprint(response) 7085 >>> 7086 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7087 7088 :param callback function: The callback function 7089 for asynchronous request. (optional) 7090 :param str account_id: The external account number (int) or account ID Guid. (required) 7091 :param str permission_profile_id: (required) 7092 :param str include: 7093 :param PermissionProfile permission_profile: 7094 :return: PermissionProfile 7095 If the method is called asynchronously, 7096 returns the request thread. 7097 """ 7098 kwargs['_return_http_data_only'] = True 7099 if kwargs.get('callback'): 7100 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7101 else: 7102 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7103 return data 7104 7105 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7106 """ 7107 Updates a permission profile within the specified account. 7108 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7109 This method makes a synchronous HTTP request by default. To make an 7110 asynchronous HTTP request, please define a `callback` function 7111 to be invoked when receiving the response. 7112 >>> def callback_function(response): 7113 >>> pprint(response) 7114 >>> 7115 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7116 7117 :param callback function: The callback function 7118 for asynchronous request. (optional) 7119 :param str account_id: The external account number (int) or account ID Guid. (required) 7120 :param str permission_profile_id: (required) 7121 :param str include: 7122 :param PermissionProfile permission_profile: 7123 :return: PermissionProfile 7124 If the method is called asynchronously, 7125 returns the request thread. 7126 """ 7127 7128 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7129 all_params.append('callback') 7130 all_params.append('_return_http_data_only') 7131 all_params.append('_preload_content') 7132 all_params.append('_request_timeout') 7133 7134 params = locals() 7135 for key, val in iteritems(params['kwargs']): 7136 if key not in all_params: 7137 raise TypeError( 7138 "Got an unexpected keyword argument '%s'" 7139 " to method update_permission_profile" % key 7140 ) 7141 params[key] = val 7142 del params['kwargs'] 7143 # verify the required parameter 'account_id' is set 7144 if ('account_id' not in params) or (params['account_id'] is None): 7145 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7146 # verify the required parameter 'permission_profile_id' is set 7147 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7148 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7149 7150 7151 collection_formats = {} 7152 7153 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 7154 path_params = {} 7155 if 'account_id' in params: 7156 path_params['accountId'] = params['account_id'] 7157 if 'permission_profile_id' in params: 7158 path_params['permissionProfileId'] = params['permission_profile_id'] 7159 7160 query_params = {} 7161 if 'include' in params: 7162 query_params['include'] = params['include'] 7163 7164 header_params = {} 7165 7166 form_params = [] 7167 local_var_files = {} 7168 7169 body_params = None 7170 if 'permission_profile' in params: 7171 body_params = params['permission_profile'] 7172 # HTTP header `Accept` 7173 header_params['Accept'] = self.api_client.\ 7174 select_header_accept(['application/json']) 7175 7176 # Authentication setting 7177 auth_settings = [] 7178 7179 return self.api_client.call_api(resource_path, 'PUT', 7180 path_params, 7181 query_params, 7182 header_params, 7183 body=body_params, 7184 post_params=form_params, 7185 files=local_var_files, 7186 response_type='PermissionProfile', 7187 auth_settings=auth_settings, 7188 callback=params.get('callback'), 7189 _return_http_data_only=params.get('_return_http_data_only'), 7190 _preload_content=params.get('_preload_content', True), 7191 _request_timeout=params.get('_request_timeout'), 7192 collection_formats=collection_formats) 7193 7194 def update_settings(self, account_id, **kwargs): 7195 """ 7196 Updates the account settings for an account. 7197 Updates the account settings for the specified account. 7198 This method makes a synchronous HTTP request by default. To make an 7199 asynchronous HTTP request, please define a `callback` function 7200 to be invoked when receiving the response. 7201 >>> def callback_function(response): 7202 >>> pprint(response) 7203 >>> 7204 >>> thread = api.update_settings(account_id, callback=callback_function) 7205 7206 :param callback function: The callback function 7207 for asynchronous request. (optional) 7208 :param str account_id: The external account number (int) or account ID Guid. (required) 7209 :param AccountSettingsInformation account_settings_information: 7210 :return: None 7211 If the method is called asynchronously, 7212 returns the request thread. 7213 """ 7214 kwargs['_return_http_data_only'] = True 7215 if kwargs.get('callback'): 7216 return self.update_settings_with_http_info(account_id, **kwargs) 7217 else: 7218 (data) = self.update_settings_with_http_info(account_id, **kwargs) 7219 return data 7220 7221 def update_settings_with_http_info(self, account_id, **kwargs): 7222 """ 7223 Updates the account settings for an account. 7224 Updates the account settings for the specified account. 7225 This method makes a synchronous HTTP request by default. To make an 7226 asynchronous HTTP request, please define a `callback` function 7227 to be invoked when receiving the response. 7228 >>> def callback_function(response): 7229 >>> pprint(response) 7230 >>> 7231 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 7232 7233 :param callback function: The callback function 7234 for asynchronous request. (optional) 7235 :param str account_id: The external account number (int) or account ID Guid. (required) 7236 :param AccountSettingsInformation account_settings_information: 7237 :return: None 7238 If the method is called asynchronously, 7239 returns the request thread. 7240 """ 7241 7242 all_params = ['account_id', 'account_settings_information'] 7243 all_params.append('callback') 7244 all_params.append('_return_http_data_only') 7245 all_params.append('_preload_content') 7246 all_params.append('_request_timeout') 7247 7248 params = locals() 7249 for key, val in iteritems(params['kwargs']): 7250 if key not in all_params: 7251 raise TypeError( 7252 "Got an unexpected keyword argument '%s'" 7253 " to method update_settings" % key 7254 ) 7255 params[key] = val 7256 del params['kwargs'] 7257 # verify the required parameter 'account_id' is set 7258 if ('account_id' not in params) or (params['account_id'] is None): 7259 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 7260 7261 7262 collection_formats = {} 7263 7264 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 7265 path_params = {} 7266 if 'account_id' in params: 7267 path_params['accountId'] = params['account_id'] 7268 7269 query_params = {} 7270 7271 header_params = {} 7272 7273 form_params = [] 7274 local_var_files = {} 7275 7276 body_params = None 7277 if 'account_settings_information' in params: 7278 body_params = params['account_settings_information'] 7279 # HTTP header `Accept` 7280 header_params['Accept'] = self.api_client.\ 7281 select_header_accept(['application/json']) 7282 7283 # Authentication setting 7284 auth_settings = [] 7285 7286 return self.api_client.call_api(resource_path, 'PUT', 7287 path_params, 7288 query_params, 7289 header_params, 7290 body=body_params, 7291 post_params=form_params, 7292 files=local_var_files, 7293 response_type=None, 7294 auth_settings=auth_settings, 7295 callback=params.get('callback'), 7296 _return_http_data_only=params.get('_return_http_data_only'), 7297 _preload_content=params.get('_preload_content', True), 7298 _request_timeout=params.get('_request_timeout'), 7299 collection_formats=collection_formats) 7300 7301 def update_shared_access(self, account_id, **kwargs): 7302 """ 7303 Reserved: Sets the shared access information for users. 7304 Reserved: Sets the shared access information for one or more users. 7305 This method makes a synchronous HTTP request by default. To make an 7306 asynchronous HTTP request, please define a `callback` function 7307 to be invoked when receiving the response. 7308 >>> def callback_function(response): 7309 >>> pprint(response) 7310 >>> 7311 >>> thread = api.update_shared_access(account_id, callback=callback_function) 7312 7313 :param callback function: The callback function 7314 for asynchronous request. (optional) 7315 :param str account_id: The external account number (int) or account ID Guid. (required) 7316 :param str item_type: 7317 :param str preserve_existing_shared_access: 7318 :param str user_ids: 7319 :param AccountSharedAccess account_shared_access: 7320 :return: AccountSharedAccess 7321 If the method is called asynchronously, 7322 returns the request thread. 7323 """ 7324 kwargs['_return_http_data_only'] = True 7325 if kwargs.get('callback'): 7326 return self.update_shared_access_with_http_info(account_id, **kwargs) 7327 else: 7328 (data) = self.update_shared_access_with_http_info(account_id, **kwargs) 7329 return data 7330 7331 def update_shared_access_with_http_info(self, account_id, **kwargs): 7332 """ 7333 Reserved: Sets the shared access information for users. 7334 Reserved: Sets the shared access information for one or more users. 7335 This method makes a synchronous HTTP request by default. To make an 7336 asynchronous HTTP request, please define a `callback` function 7337 to be invoked when receiving the response. 7338 >>> def callback_function(response): 7339 >>> pprint(response) 7340 >>> 7341 >>> thread = api.update_shared_access_with_http_info(account_id, callback=callback_function) 7342 7343 :param callback function: The callback function 7344 for asynchronous request. (optional) 7345 :param str account_id: The external account number (int) or account ID Guid. (required) 7346 :param str item_type: 7347 :param str preserve_existing_shared_access: 7348 :param str user_ids: 7349 :param AccountSharedAccess account_shared_access: 7350 :return: AccountSharedAccess 7351 If the method is called asynchronously, 7352 returns the request thread. 7353 """ 7354 7355 all_params = ['account_id', 'item_type', 'preserve_existing_shared_access', 'user_ids', 'account_shared_access'] 7356 all_params.append('callback') 7357 all_params.append('_return_http_data_only') 7358 all_params.append('_preload_content') 7359 all_params.append('_request_timeout') 7360 7361 params = locals() 7362 for key, val in iteritems(params['kwargs']): 7363 if key not in all_params: 7364 raise TypeError( 7365 "Got an unexpected keyword argument '%s'" 7366 " to method update_shared_access" % key 7367 ) 7368 params[key] = val 7369 del params['kwargs'] 7370 # verify the required parameter 'account_id' is set 7371 if ('account_id' not in params) or (params['account_id'] is None): 7372 raise ValueError("Missing the required parameter `account_id` when calling `update_shared_access`") 7373 7374 7375 collection_formats = {} 7376 7377 resource_path = '/v2.1/accounts/{accountId}/shared_access'.replace('{format}', 'json') 7378 path_params = {} 7379 if 'account_id' in params: 7380 path_params['accountId'] = params['account_id'] 7381 7382 query_params = {} 7383 if 'item_type' in params: 7384 query_params['item_type'] = params['item_type'] 7385 if 'preserve_existing_shared_access' in params: 7386 query_params['preserve_existing_shared_access'] = params['preserve_existing_shared_access'] 7387 if 'user_ids' in params: 7388 query_params['user_ids'] = params['user_ids'] 7389 7390 header_params = {} 7391 7392 form_params = [] 7393 local_var_files = {} 7394 7395 body_params = None 7396 if 'account_shared_access' in params: 7397 body_params = params['account_shared_access'] 7398 # HTTP header `Accept` 7399 header_params['Accept'] = self.api_client.\ 7400 select_header_accept(['application/json']) 7401 7402 # Authentication setting 7403 auth_settings = [] 7404 7405 return self.api_client.call_api(resource_path, 'PUT', 7406 path_params, 7407 query_params, 7408 header_params, 7409 body=body_params, 7410 post_params=form_params, 7411 files=local_var_files, 7412 response_type='AccountSharedAccess', 7413 auth_settings=auth_settings, 7414 callback=params.get('callback'), 7415 _return_http_data_only=params.get('_return_http_data_only'), 7416 _preload_content=params.get('_preload_content', True), 7417 _request_timeout=params.get('_request_timeout'), 7418 collection_formats=collection_formats) 7419 7420 def update_watermark(self, account_id, **kwargs): 7421 """ 7422 Update watermark information. 7423 7424 This method makes a synchronous HTTP request by default. To make an 7425 asynchronous HTTP request, please define a `callback` function 7426 to be invoked when receiving the response. 7427 >>> def callback_function(response): 7428 >>> pprint(response) 7429 >>> 7430 >>> thread = api.update_watermark(account_id, callback=callback_function) 7431 7432 :param callback function: The callback function 7433 for asynchronous request. (optional) 7434 :param str account_id: The external account number (int) or account ID Guid. (required) 7435 :param Watermark watermark: 7436 :return: Watermark 7437 If the method is called asynchronously, 7438 returns the request thread. 7439 """ 7440 kwargs['_return_http_data_only'] = True 7441 if kwargs.get('callback'): 7442 return self.update_watermark_with_http_info(account_id, **kwargs) 7443 else: 7444 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 7445 return data 7446 7447 def update_watermark_with_http_info(self, account_id, **kwargs): 7448 """ 7449 Update watermark information. 7450 7451 This method makes a synchronous HTTP request by default. To make an 7452 asynchronous HTTP request, please define a `callback` function 7453 to be invoked when receiving the response. 7454 >>> def callback_function(response): 7455 >>> pprint(response) 7456 >>> 7457 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 7458 7459 :param callback function: The callback function 7460 for asynchronous request. (optional) 7461 :param str account_id: The external account number (int) or account ID Guid. (required) 7462 :param Watermark watermark: 7463 :return: Watermark 7464 If the method is called asynchronously, 7465 returns the request thread. 7466 """ 7467 7468 all_params = ['account_id', 'watermark'] 7469 all_params.append('callback') 7470 all_params.append('_return_http_data_only') 7471 all_params.append('_preload_content') 7472 all_params.append('_request_timeout') 7473 7474 params = locals() 7475 for key, val in iteritems(params['kwargs']): 7476 if key not in all_params: 7477 raise TypeError( 7478 "Got an unexpected keyword argument '%s'" 7479 " to method update_watermark" % key 7480 ) 7481 params[key] = val 7482 del params['kwargs'] 7483 # verify the required parameter 'account_id' is set 7484 if ('account_id' not in params) or (params['account_id'] is None): 7485 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 7486 7487 7488 collection_formats = {} 7489 7490 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 7491 path_params = {} 7492 if 'account_id' in params: 7493 path_params['accountId'] = params['account_id'] 7494 7495 query_params = {} 7496 7497 header_params = {} 7498 7499 form_params = [] 7500 local_var_files = {} 7501 7502 body_params = None 7503 if 'watermark' in params: 7504 body_params = params['watermark'] 7505 # HTTP header `Accept` 7506 header_params['Accept'] = self.api_client.\ 7507 select_header_accept(['application/json']) 7508 7509 # Authentication setting 7510 auth_settings = [] 7511 7512 return self.api_client.call_api(resource_path, 'PUT', 7513 path_params, 7514 query_params, 7515 header_params, 7516 body=body_params, 7517 post_params=form_params, 7518 files=local_var_files, 7519 response_type='Watermark', 7520 auth_settings=auth_settings, 7521 callback=params.get('callback'), 7522 _return_http_data_only=params.get('_return_http_data_only'), 7523 _preload_content=params.get('_preload_content', True), 7524 _request_timeout=params.get('_request_timeout'), 7525 collection_formats=collection_formats)
NOTE: This class is auto generated by the swagger code generator program. Do not edit the class manually. Ref: https://github.com/swagger-api/swagger-codegen
def
create(self, **kwargs)
44 def create(self, **kwargs): 45 """ 46 Creates new accounts. 47 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 48 This method makes a synchronous HTTP request by default. To make an 49 asynchronous HTTP request, please define a `callback` function 50 to be invoked when receiving the response. 51 >>> def callback_function(response): 52 >>> pprint(response) 53 >>> 54 >>> thread = api.create(callback=callback_function) 55 56 :param callback function: The callback function 57 for asynchronous request. (optional) 58 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 59 :param NewAccountDefinition new_account_definition: 60 :return: NewAccountSummary 61 If the method is called asynchronously, 62 returns the request thread. 63 """ 64 kwargs['_return_http_data_only'] = True 65 if kwargs.get('callback'): 66 return self.create_with_http_info(**kwargs) 67 else: 68 (data) = self.create_with_http_info(**kwargs) 69 return data
Creates new accounts.
Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a Accounts:create call with the information included within a newAccountRequests element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a newAccountDefinition property inside the newAccountRequests element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an errorDetails node is added in the response to each specific request that failed.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str preview_billing_plan: When set to true, creates the account using a preview billing plan.
- NewAccountDefinition new_account_definition:
Returns
NewAccountSummary If the method is called asynchronously, returns the request thread.
def
create_with_http_info(self, **kwargs)
71 def create_with_http_info(self, **kwargs): 72 """ 73 Creates new accounts. 74 Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a [Accounts:create](accounts_create) call with the information included within a `newAccountRequests` element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a `newAccountDefinition` property inside the `newAccountRequests` element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an `errorDetails` node is added in the response to each specific request that failed. 75 This method makes a synchronous HTTP request by default. To make an 76 asynchronous HTTP request, please define a `callback` function 77 to be invoked when receiving the response. 78 >>> def callback_function(response): 79 >>> pprint(response) 80 >>> 81 >>> thread = api.create_with_http_info(callback=callback_function) 82 83 :param callback function: The callback function 84 for asynchronous request. (optional) 85 :param str preview_billing_plan: When set to **true**, creates the account using a preview billing plan. 86 :param NewAccountDefinition new_account_definition: 87 :return: NewAccountSummary 88 If the method is called asynchronously, 89 returns the request thread. 90 """ 91 92 all_params = ['preview_billing_plan', 'new_account_definition'] 93 all_params.append('callback') 94 all_params.append('_return_http_data_only') 95 all_params.append('_preload_content') 96 all_params.append('_request_timeout') 97 98 params = locals() 99 for key, val in iteritems(params['kwargs']): 100 if key not in all_params: 101 raise TypeError( 102 "Got an unexpected keyword argument '%s'" 103 " to method create" % key 104 ) 105 params[key] = val 106 del params['kwargs'] 107 108 109 collection_formats = {} 110 111 resource_path = '/v2.1/accounts'.replace('{format}', 'json') 112 path_params = {} 113 114 query_params = {} 115 if 'preview_billing_plan' in params: 116 query_params['preview_billing_plan'] = params['preview_billing_plan'] 117 118 header_params = {} 119 120 form_params = [] 121 local_var_files = {} 122 123 body_params = None 124 if 'new_account_definition' in params: 125 body_params = params['new_account_definition'] 126 # HTTP header `Accept` 127 header_params['Accept'] = self.api_client.\ 128 select_header_accept(['application/json']) 129 130 # Authentication setting 131 auth_settings = [] 132 133 return self.api_client.call_api(resource_path, 'POST', 134 path_params, 135 query_params, 136 header_params, 137 body=body_params, 138 post_params=form_params, 139 files=local_var_files, 140 response_type='NewAccountSummary', 141 auth_settings=auth_settings, 142 callback=params.get('callback'), 143 _return_http_data_only=params.get('_return_http_data_only'), 144 _preload_content=params.get('_preload_content', True), 145 _request_timeout=params.get('_request_timeout'), 146 collection_formats=collection_formats)
Creates new accounts.
Creates new DocuSign service accounts. This is used to create multiple DocuSign accounts with one call. It uses the same information and formats as the normal a Accounts:create call with the information included within a newAccountRequests element. A maximum of 100 new accounts can be created at one time. Note that the structure of the XML request is slightly different than the JSON request, in that the new account information is included in a newAccountDefinition property inside the newAccountRequests element. Response The response returns the new account ID, password and the default user information for each newly created account. A 201 code is returned if the call succeeded. While the call may have succeed, some of the individual account requests may have failed. In the case of failures to create the account, an errorDetails node is added in the response to each specific request that failed.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_with_http_info(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str preview_billing_plan: When set to true, creates the account using a preview billing plan.
- NewAccountDefinition new_account_definition:
Returns
NewAccountSummary If the method is called asynchronously, returns the request thread.
def
create_account_signatures(self, account_id, **kwargs)
148 def create_account_signatures(self, account_id, **kwargs): 149 """ 150 Adds/updates one or more account signatures. This request may include images in multi-part format. 151 152 This method makes a synchronous HTTP request by default. To make an 153 asynchronous HTTP request, please define a `callback` function 154 to be invoked when receiving the response. 155 >>> def callback_function(response): 156 >>> pprint(response) 157 >>> 158 >>> thread = api.create_account_signatures(account_id, callback=callback_function) 159 160 :param callback function: The callback function 161 for asynchronous request. (optional) 162 :param str account_id: The external account number (int) or account ID Guid. (required) 163 :param str decode_only: 164 :param AccountSignaturesInformation account_signatures_information: 165 :return: AccountSignaturesInformation 166 If the method is called asynchronously, 167 returns the request thread. 168 """ 169 kwargs['_return_http_data_only'] = True 170 if kwargs.get('callback'): 171 return self.create_account_signatures_with_http_info(account_id, **kwargs) 172 else: 173 (data) = self.create_account_signatures_with_http_info(account_id, **kwargs) 174 return data
Adds/updates one or more account signatures. This request may include images in multi-part format.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_account_signatures(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str decode_only:
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
create_account_signatures_with_http_info(self, account_id, **kwargs)
176 def create_account_signatures_with_http_info(self, account_id, **kwargs): 177 """ 178 Adds/updates one or more account signatures. This request may include images in multi-part format. 179 180 This method makes a synchronous HTTP request by default. To make an 181 asynchronous HTTP request, please define a `callback` function 182 to be invoked when receiving the response. 183 >>> def callback_function(response): 184 >>> pprint(response) 185 >>> 186 >>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function) 187 188 :param callback function: The callback function 189 for asynchronous request. (optional) 190 :param str account_id: The external account number (int) or account ID Guid. (required) 191 :param str decode_only: 192 :param AccountSignaturesInformation account_signatures_information: 193 :return: AccountSignaturesInformation 194 If the method is called asynchronously, 195 returns the request thread. 196 """ 197 198 all_params = ['account_id', 'decode_only', 'account_signatures_information'] 199 all_params.append('callback') 200 all_params.append('_return_http_data_only') 201 all_params.append('_preload_content') 202 all_params.append('_request_timeout') 203 204 params = locals() 205 for key, val in iteritems(params['kwargs']): 206 if key not in all_params: 207 raise TypeError( 208 "Got an unexpected keyword argument '%s'" 209 " to method create_account_signatures" % key 210 ) 211 params[key] = val 212 del params['kwargs'] 213 # verify the required parameter 'account_id' is set 214 if ('account_id' not in params) or (params['account_id'] is None): 215 raise ValueError("Missing the required parameter `account_id` when calling `create_account_signatures`") 216 217 218 collection_formats = {} 219 220 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 221 path_params = {} 222 if 'account_id' in params: 223 path_params['accountId'] = params['account_id'] 224 225 query_params = {} 226 if 'decode_only' in params: 227 query_params['decode_only'] = params['decode_only'] 228 229 header_params = {} 230 231 form_params = [] 232 local_var_files = {} 233 234 body_params = None 235 if 'account_signatures_information' in params: 236 body_params = params['account_signatures_information'] 237 # HTTP header `Accept` 238 header_params['Accept'] = self.api_client.\ 239 select_header_accept(['application/json']) 240 241 # Authentication setting 242 auth_settings = [] 243 244 return self.api_client.call_api(resource_path, 'POST', 245 path_params, 246 query_params, 247 header_params, 248 body=body_params, 249 post_params=form_params, 250 files=local_var_files, 251 response_type='AccountSignaturesInformation', 252 auth_settings=auth_settings, 253 callback=params.get('callback'), 254 _return_http_data_only=params.get('_return_http_data_only'), 255 _preload_content=params.get('_preload_content', True), 256 _request_timeout=params.get('_request_timeout'), 257 collection_formats=collection_formats)
Adds/updates one or more account signatures. This request may include images in multi-part format.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_account_signatures_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str decode_only:
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
create_brand(self, account_id, **kwargs)
259 def create_brand(self, account_id, **kwargs): 260 """ 261 Creates one or more brand profile files for the account. 262 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 263 This method makes a synchronous HTTP request by default. To make an 264 asynchronous HTTP request, please define a `callback` function 265 to be invoked when receiving the response. 266 >>> def callback_function(response): 267 >>> pprint(response) 268 >>> 269 >>> thread = api.create_brand(account_id, callback=callback_function) 270 271 :param callback function: The callback function 272 for asynchronous request. (optional) 273 :param str account_id: The external account number (int) or account ID GUID. (required) 274 :param Brand brand: 275 :return: BrandsResponse 276 If the method is called asynchronously, 277 returns the request thread. 278 """ 279 kwargs['_return_http_data_only'] = True 280 if kwargs.get('callback'): 281 return self.create_brand_with_http_info(account_id, **kwargs) 282 else: 283 (data) = self.create_brand_with_http_info(account_id, **kwargs) 284 return data
Creates one or more brand profile files for the account.
Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSig) must be set to true for the account to use this call. An error is returned if brandId property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the Content-Type must be application/zip.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_brand(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- Brand brand:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
create_brand_with_http_info(self, account_id, **kwargs)
286 def create_brand_with_http_info(self, account_id, **kwargs): 287 """ 288 Creates one or more brand profile files for the account. 289 Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSig`) must be set to **true** for the account to use this call. An error is returned if `brandId` property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the `Content-Type` must be `application/zip`. 290 This method makes a synchronous HTTP request by default. To make an 291 asynchronous HTTP request, please define a `callback` function 292 to be invoked when receiving the response. 293 >>> def callback_function(response): 294 >>> pprint(response) 295 >>> 296 >>> thread = api.create_brand_with_http_info(account_id, callback=callback_function) 297 298 :param callback function: The callback function 299 for asynchronous request. (optional) 300 :param str account_id: The external account number (int) or account ID GUID. (required) 301 :param Brand brand: 302 :return: BrandsResponse 303 If the method is called asynchronously, 304 returns the request thread. 305 """ 306 307 all_params = ['account_id', 'brand'] 308 all_params.append('callback') 309 all_params.append('_return_http_data_only') 310 all_params.append('_preload_content') 311 all_params.append('_request_timeout') 312 313 params = locals() 314 for key, val in iteritems(params['kwargs']): 315 if key not in all_params: 316 raise TypeError( 317 "Got an unexpected keyword argument '%s'" 318 " to method create_brand" % key 319 ) 320 params[key] = val 321 del params['kwargs'] 322 # verify the required parameter 'account_id' is set 323 if ('account_id' not in params) or (params['account_id'] is None): 324 raise ValueError("Missing the required parameter `account_id` when calling `create_brand`") 325 326 327 collection_formats = {} 328 329 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 330 path_params = {} 331 if 'account_id' in params: 332 path_params['accountId'] = params['account_id'] 333 334 query_params = {} 335 336 header_params = {} 337 338 form_params = [] 339 local_var_files = {} 340 341 body_params = None 342 if 'brand' in params: 343 body_params = params['brand'] 344 # HTTP header `Accept` 345 header_params['Accept'] = self.api_client.\ 346 select_header_accept(['application/json']) 347 348 # Authentication setting 349 auth_settings = [] 350 351 return self.api_client.call_api(resource_path, 'POST', 352 path_params, 353 query_params, 354 header_params, 355 body=body_params, 356 post_params=form_params, 357 files=local_var_files, 358 response_type='BrandsResponse', 359 auth_settings=auth_settings, 360 callback=params.get('callback'), 361 _return_http_data_only=params.get('_return_http_data_only'), 362 _preload_content=params.get('_preload_content', True), 363 _request_timeout=params.get('_request_timeout'), 364 collection_formats=collection_formats)
Creates one or more brand profile files for the account.
Creates one or more brand profile files for the account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSig) must be set to true for the account to use this call. An error is returned if brandId property for a brand profile is already set for the account. To upload a new version of an existing brand profile, you must delete the profile and then upload the newer version. When brand profile files are being uploaded, they must be combined into one zip file and the Content-Type must be application/zip.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_brand_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- Brand brand:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
create_custom_field(self, account_id, **kwargs)
366 def create_custom_field(self, account_id, **kwargs): 367 """ 368 Creates an acount custom field. 369 This method creates a custom field and makes it available for all new envelopes associated with an account. 370 This method makes a synchronous HTTP request by default. To make an 371 asynchronous HTTP request, please define a `callback` function 372 to be invoked when receiving the response. 373 >>> def callback_function(response): 374 >>> pprint(response) 375 >>> 376 >>> thread = api.create_custom_field(account_id, callback=callback_function) 377 378 :param callback function: The callback function 379 for asynchronous request. (optional) 380 :param str account_id: The external account number (int) or account ID Guid. (required) 381 :param str apply_to_templates: 382 :param CustomField custom_field: 383 :return: CustomFields 384 If the method is called asynchronously, 385 returns the request thread. 386 """ 387 kwargs['_return_http_data_only'] = True 388 if kwargs.get('callback'): 389 return self.create_custom_field_with_http_info(account_id, **kwargs) 390 else: 391 (data) = self.create_custom_field_with_http_info(account_id, **kwargs) 392 return data
Creates an acount custom field.
This method creates a custom field and makes it available for all new envelopes associated with an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_custom_field(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
create_custom_field_with_http_info(self, account_id, **kwargs)
394 def create_custom_field_with_http_info(self, account_id, **kwargs): 395 """ 396 Creates an acount custom field. 397 This method creates a custom field and makes it available for all new envelopes associated with an account. 398 This method makes a synchronous HTTP request by default. To make an 399 asynchronous HTTP request, please define a `callback` function 400 to be invoked when receiving the response. 401 >>> def callback_function(response): 402 >>> pprint(response) 403 >>> 404 >>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function) 405 406 :param callback function: The callback function 407 for asynchronous request. (optional) 408 :param str account_id: The external account number (int) or account ID Guid. (required) 409 :param str apply_to_templates: 410 :param CustomField custom_field: 411 :return: CustomFields 412 If the method is called asynchronously, 413 returns the request thread. 414 """ 415 416 all_params = ['account_id', 'apply_to_templates', 'custom_field'] 417 all_params.append('callback') 418 all_params.append('_return_http_data_only') 419 all_params.append('_preload_content') 420 all_params.append('_request_timeout') 421 422 params = locals() 423 for key, val in iteritems(params['kwargs']): 424 if key not in all_params: 425 raise TypeError( 426 "Got an unexpected keyword argument '%s'" 427 " to method create_custom_field" % key 428 ) 429 params[key] = val 430 del params['kwargs'] 431 # verify the required parameter 'account_id' is set 432 if ('account_id' not in params) or (params['account_id'] is None): 433 raise ValueError("Missing the required parameter `account_id` when calling `create_custom_field`") 434 435 436 collection_formats = {} 437 438 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 439 path_params = {} 440 if 'account_id' in params: 441 path_params['accountId'] = params['account_id'] 442 443 query_params = {} 444 if 'apply_to_templates' in params: 445 query_params['apply_to_templates'] = params['apply_to_templates'] 446 447 header_params = {} 448 449 form_params = [] 450 local_var_files = {} 451 452 body_params = None 453 if 'custom_field' in params: 454 body_params = params['custom_field'] 455 # HTTP header `Accept` 456 header_params['Accept'] = self.api_client.\ 457 select_header_accept(['application/json']) 458 459 # Authentication setting 460 auth_settings = [] 461 462 return self.api_client.call_api(resource_path, 'POST', 463 path_params, 464 query_params, 465 header_params, 466 body=body_params, 467 post_params=form_params, 468 files=local_var_files, 469 response_type='CustomFields', 470 auth_settings=auth_settings, 471 callback=params.get('callback'), 472 _return_http_data_only=params.get('_return_http_data_only'), 473 _preload_content=params.get('_preload_content', True), 474 _request_timeout=params.get('_request_timeout'), 475 collection_formats=collection_formats)
Creates an acount custom field.
This method creates a custom field and makes it available for all new envelopes associated with an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_custom_field_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
create_permission_profile(self, account_id, **kwargs)
477 def create_permission_profile(self, account_id, **kwargs): 478 """ 479 Creates a new permission profile in the specified account. 480 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 481 This method makes a synchronous HTTP request by default. To make an 482 asynchronous HTTP request, please define a `callback` function 483 to be invoked when receiving the response. 484 >>> def callback_function(response): 485 >>> pprint(response) 486 >>> 487 >>> thread = api.create_permission_profile(account_id, callback=callback_function) 488 489 :param callback function: The callback function 490 for asynchronous request. (optional) 491 :param str account_id: The external account number (int) or account ID Guid. (required) 492 :param str include: 493 :param PermissionProfile permission_profile: 494 :return: PermissionProfile 495 If the method is called asynchronously, 496 returns the request thread. 497 """ 498 kwargs['_return_http_data_only'] = True 499 if kwargs.get('callback'): 500 return self.create_permission_profile_with_http_info(account_id, **kwargs) 501 else: 502 (data) = self.create_permission_profile_with_http_info(account_id, **kwargs) 503 return data
Creates a new permission profile in the specified account.
This method creates a new permission profile for an account. ### Related topics - How to create a permission profile
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_permission_profile(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
create_permission_profile_with_http_info(self, account_id, **kwargs)
505 def create_permission_profile_with_http_info(self, account_id, **kwargs): 506 """ 507 Creates a new permission profile in the specified account. 508 This method creates a new permission profile for an account. ### Related topics - [How to create a permission profile](/docs/esign-rest-api/how-to/permission-profile-creating/) 509 This method makes a synchronous HTTP request by default. To make an 510 asynchronous HTTP request, please define a `callback` function 511 to be invoked when receiving the response. 512 >>> def callback_function(response): 513 >>> pprint(response) 514 >>> 515 >>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function) 516 517 :param callback function: The callback function 518 for asynchronous request. (optional) 519 :param str account_id: The external account number (int) or account ID Guid. (required) 520 :param str include: 521 :param PermissionProfile permission_profile: 522 :return: PermissionProfile 523 If the method is called asynchronously, 524 returns the request thread. 525 """ 526 527 all_params = ['account_id', 'include', 'permission_profile'] 528 all_params.append('callback') 529 all_params.append('_return_http_data_only') 530 all_params.append('_preload_content') 531 all_params.append('_request_timeout') 532 533 params = locals() 534 for key, val in iteritems(params['kwargs']): 535 if key not in all_params: 536 raise TypeError( 537 "Got an unexpected keyword argument '%s'" 538 " to method create_permission_profile" % key 539 ) 540 params[key] = val 541 del params['kwargs'] 542 # verify the required parameter 'account_id' is set 543 if ('account_id' not in params) or (params['account_id'] is None): 544 raise ValueError("Missing the required parameter `account_id` when calling `create_permission_profile`") 545 546 547 collection_formats = {} 548 549 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 550 path_params = {} 551 if 'account_id' in params: 552 path_params['accountId'] = params['account_id'] 553 554 query_params = {} 555 if 'include' in params: 556 query_params['include'] = params['include'] 557 558 header_params = {} 559 560 form_params = [] 561 local_var_files = {} 562 563 body_params = None 564 if 'permission_profile' in params: 565 body_params = params['permission_profile'] 566 # HTTP header `Accept` 567 header_params['Accept'] = self.api_client.\ 568 select_header_accept(['application/json']) 569 570 # Authentication setting 571 auth_settings = [] 572 573 return self.api_client.call_api(resource_path, 'POST', 574 path_params, 575 query_params, 576 header_params, 577 body=body_params, 578 post_params=form_params, 579 files=local_var_files, 580 response_type='PermissionProfile', 581 auth_settings=auth_settings, 582 callback=params.get('callback'), 583 _return_http_data_only=params.get('_return_http_data_only'), 584 _preload_content=params.get('_preload_content', True), 585 _request_timeout=params.get('_request_timeout'), 586 collection_formats=collection_formats)
Creates a new permission profile in the specified account.
This method creates a new permission profile for an account. ### Related topics - How to create a permission profile
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.create_permission_profile_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
delete(self, account_id, **kwargs)
588 def delete(self, account_id, **kwargs): 589 """ 590 Deletes the specified account. 591 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 592 This method makes a synchronous HTTP request by default. To make an 593 asynchronous HTTP request, please define a `callback` function 594 to be invoked when receiving the response. 595 >>> def callback_function(response): 596 >>> pprint(response) 597 >>> 598 >>> thread = api.delete(account_id, callback=callback_function) 599 600 :param callback function: The callback function 601 for asynchronous request. (optional) 602 :param str account_id: The external account number (int) or account ID Guid. (required) 603 :return: None 604 If the method is called asynchronously, 605 returns the request thread. 606 """ 607 kwargs['_return_http_data_only'] = True 608 if kwargs.get('callback'): 609 return self.delete_with_http_info(account_id, **kwargs) 610 else: 611 (data) = self.delete_with_http_info(account_id, **kwargs) 612 return data
Deletes the specified account.
This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_with_http_info(self, account_id, **kwargs)
614 def delete_with_http_info(self, account_id, **kwargs): 615 """ 616 Deletes the specified account. 617 This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign. 618 This method makes a synchronous HTTP request by default. To make an 619 asynchronous HTTP request, please define a `callback` function 620 to be invoked when receiving the response. 621 >>> def callback_function(response): 622 >>> pprint(response) 623 >>> 624 >>> thread = api.delete_with_http_info(account_id, callback=callback_function) 625 626 :param callback function: The callback function 627 for asynchronous request. (optional) 628 :param str account_id: The external account number (int) or account ID Guid. (required) 629 :return: None 630 If the method is called asynchronously, 631 returns the request thread. 632 """ 633 634 all_params = ['account_id'] 635 all_params.append('callback') 636 all_params.append('_return_http_data_only') 637 all_params.append('_preload_content') 638 all_params.append('_request_timeout') 639 640 params = locals() 641 for key, val in iteritems(params['kwargs']): 642 if key not in all_params: 643 raise TypeError( 644 "Got an unexpected keyword argument '%s'" 645 " to method delete" % key 646 ) 647 params[key] = val 648 del params['kwargs'] 649 # verify the required parameter 'account_id' is set 650 if ('account_id' not in params) or (params['account_id'] is None): 651 raise ValueError("Missing the required parameter `account_id` when calling `delete`") 652 653 654 collection_formats = {} 655 656 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 657 path_params = {} 658 if 'account_id' in params: 659 path_params['accountId'] = params['account_id'] 660 661 query_params = {} 662 663 header_params = {} 664 665 form_params = [] 666 local_var_files = {} 667 668 body_params = None 669 # HTTP header `Accept` 670 header_params['Accept'] = self.api_client.\ 671 select_header_accept(['application/json']) 672 673 # Authentication setting 674 auth_settings = [] 675 676 return self.api_client.call_api(resource_path, 'DELETE', 677 path_params, 678 query_params, 679 header_params, 680 body=body_params, 681 post_params=form_params, 682 files=local_var_files, 683 response_type=None, 684 auth_settings=auth_settings, 685 callback=params.get('callback'), 686 _return_http_data_only=params.get('_return_http_data_only'), 687 _preload_content=params.get('_preload_content', True), 688 _request_timeout=params.get('_request_timeout'), 689 collection_formats=collection_formats)
Deletes the specified account.
This closes the specified account. You must be an account admin to close your account. Once closed, an account must be reopened by DocuSign.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_account_signature(self, account_id, signature_id, **kwargs)
691 def delete_account_signature(self, account_id, signature_id, **kwargs): 692 """ 693 Close the specified signature by Id. 694 695 This method makes a synchronous HTTP request by default. To make an 696 asynchronous HTTP request, please define a `callback` function 697 to be invoked when receiving the response. 698 >>> def callback_function(response): 699 >>> pprint(response) 700 >>> 701 >>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function) 702 703 :param callback function: The callback function 704 for asynchronous request. (optional) 705 :param str account_id: The external account number (int) or account ID Guid. (required) 706 :param str signature_id: The ID of the signature being accessed. (required) 707 :return: None 708 If the method is called asynchronously, 709 returns the request thread. 710 """ 711 kwargs['_return_http_data_only'] = True 712 if kwargs.get('callback'): 713 return self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 714 else: 715 (data) = self.delete_account_signature_with_http_info(account_id, signature_id, **kwargs) 716 return data
Close the specified signature by Id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_account_signature(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs)
718 def delete_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 719 """ 720 Close the specified signature by Id. 721 722 This method makes a synchronous HTTP request by default. To make an 723 asynchronous HTTP request, please define a `callback` function 724 to be invoked when receiving the response. 725 >>> def callback_function(response): 726 >>> pprint(response) 727 >>> 728 >>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 729 730 :param callback function: The callback function 731 for asynchronous request. (optional) 732 :param str account_id: The external account number (int) or account ID Guid. (required) 733 :param str signature_id: The ID of the signature being accessed. (required) 734 :return: None 735 If the method is called asynchronously, 736 returns the request thread. 737 """ 738 739 all_params = ['account_id', 'signature_id'] 740 all_params.append('callback') 741 all_params.append('_return_http_data_only') 742 all_params.append('_preload_content') 743 all_params.append('_request_timeout') 744 745 params = locals() 746 for key, val in iteritems(params['kwargs']): 747 if key not in all_params: 748 raise TypeError( 749 "Got an unexpected keyword argument '%s'" 750 " to method delete_account_signature" % key 751 ) 752 params[key] = val 753 del params['kwargs'] 754 # verify the required parameter 'account_id' is set 755 if ('account_id' not in params) or (params['account_id'] is None): 756 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature`") 757 # verify the required parameter 'signature_id' is set 758 if ('signature_id' not in params) or (params['signature_id'] is None): 759 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature`") 760 761 762 collection_formats = {} 763 764 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 765 path_params = {} 766 if 'account_id' in params: 767 path_params['accountId'] = params['account_id'] 768 if 'signature_id' in params: 769 path_params['signatureId'] = params['signature_id'] 770 771 query_params = {} 772 773 header_params = {} 774 775 form_params = [] 776 local_var_files = {} 777 778 body_params = None 779 # HTTP header `Accept` 780 header_params['Accept'] = self.api_client.\ 781 select_header_accept(['application/json']) 782 783 # Authentication setting 784 auth_settings = [] 785 786 return self.api_client.call_api(resource_path, 'DELETE', 787 path_params, 788 query_params, 789 header_params, 790 body=body_params, 791 post_params=form_params, 792 files=local_var_files, 793 response_type=None, 794 auth_settings=auth_settings, 795 callback=params.get('callback'), 796 _return_http_data_only=params.get('_return_http_data_only'), 797 _preload_content=params.get('_preload_content', True), 798 _request_timeout=params.get('_request_timeout'), 799 collection_formats=collection_formats)
Close the specified signature by Id.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
801 def delete_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 802 """ 803 Deletes a signature, initials, or stamps image. 804 805 This method makes a synchronous HTTP request by default. To make an 806 asynchronous HTTP request, please define a `callback` function 807 to be invoked when receiving the response. 808 >>> def callback_function(response): 809 >>> pprint(response) 810 >>> 811 >>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 812 813 :param callback function: The callback function 814 for asynchronous request. (optional) 815 :param str account_id: The external account number (int) or account ID Guid. (required) 816 :param str image_type: One of **signature_image** or **initials_image**. (required) 817 :param str signature_id: The ID of the signature being accessed. (required) 818 :return: AccountSignature 819 If the method is called asynchronously, 820 returns the request thread. 821 """ 822 kwargs['_return_http_data_only'] = True 823 if kwargs.get('callback'): 824 return self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 825 else: 826 (data) = self.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 827 return data
Deletes a signature, initials, or stamps image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
829 def delete_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 830 """ 831 Deletes a signature, initials, or stamps image. 832 833 This method makes a synchronous HTTP request by default. To make an 834 asynchronous HTTP request, please define a `callback` function 835 to be invoked when receiving the response. 836 >>> def callback_function(response): 837 >>> pprint(response) 838 >>> 839 >>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 840 841 :param callback function: The callback function 842 for asynchronous request. (optional) 843 :param str account_id: The external account number (int) or account ID Guid. (required) 844 :param str image_type: One of **signature_image** or **initials_image**. (required) 845 :param str signature_id: The ID of the signature being accessed. (required) 846 :return: AccountSignature 847 If the method is called asynchronously, 848 returns the request thread. 849 """ 850 851 all_params = ['account_id', 'image_type', 'signature_id'] 852 all_params.append('callback') 853 all_params.append('_return_http_data_only') 854 all_params.append('_preload_content') 855 all_params.append('_request_timeout') 856 857 params = locals() 858 for key, val in iteritems(params['kwargs']): 859 if key not in all_params: 860 raise TypeError( 861 "Got an unexpected keyword argument '%s'" 862 " to method delete_account_signature_image" % key 863 ) 864 params[key] = val 865 del params['kwargs'] 866 # verify the required parameter 'account_id' is set 867 if ('account_id' not in params) or (params['account_id'] is None): 868 raise ValueError("Missing the required parameter `account_id` when calling `delete_account_signature_image`") 869 # verify the required parameter 'image_type' is set 870 if ('image_type' not in params) or (params['image_type'] is None): 871 raise ValueError("Missing the required parameter `image_type` when calling `delete_account_signature_image`") 872 # verify the required parameter 'signature_id' is set 873 if ('signature_id' not in params) or (params['signature_id'] is None): 874 raise ValueError("Missing the required parameter `signature_id` when calling `delete_account_signature_image`") 875 876 877 collection_formats = {} 878 879 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 880 path_params = {} 881 if 'account_id' in params: 882 path_params['accountId'] = params['account_id'] 883 if 'image_type' in params: 884 path_params['imageType'] = params['image_type'] 885 if 'signature_id' in params: 886 path_params['signatureId'] = params['signature_id'] 887 888 query_params = {} 889 890 header_params = {} 891 892 form_params = [] 893 local_var_files = {} 894 895 body_params = None 896 # HTTP header `Accept` 897 header_params['Accept'] = self.api_client.\ 898 select_header_accept(['application/json']) 899 900 # Authentication setting 901 auth_settings = [] 902 903 return self.api_client.call_api(resource_path, 'DELETE', 904 path_params, 905 query_params, 906 header_params, 907 body=body_params, 908 post_params=form_params, 909 files=local_var_files, 910 response_type='AccountSignature', 911 auth_settings=auth_settings, 912 callback=params.get('callback'), 913 _return_http_data_only=params.get('_return_http_data_only'), 914 _preload_content=params.get('_preload_content', True), 915 _request_timeout=params.get('_request_timeout'), 916 collection_formats=collection_formats)
Deletes a signature, initials, or stamps image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
delete_brand(self, account_id, brand_id, **kwargs)
918 def delete_brand(self, account_id, brand_id, **kwargs): 919 """ 920 Removes a brand. 921 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 922 This method makes a synchronous HTTP request by default. To make an 923 asynchronous HTTP request, please define a `callback` function 924 to be invoked when receiving the response. 925 >>> def callback_function(response): 926 >>> pprint(response) 927 >>> 928 >>> thread = api.delete_brand(account_id, brand_id, callback=callback_function) 929 930 :param callback function: The callback function 931 for asynchronous request. (optional) 932 :param str account_id: The external account number (int) or account ID Guid. (required) 933 :param str brand_id: The unique identifier of a brand. (required) 934 :return: None 935 If the method is called asynchronously, 936 returns the request thread. 937 """ 938 kwargs['_return_http_data_only'] = True 939 if kwargs.get('callback'): 940 return self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 941 else: 942 (data) = self.delete_brand_with_http_info(account_id, brand_id, **kwargs) 943 return data
Removes a brand.
This method deletes a brand from an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_brand(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brand_with_http_info(self, account_id, brand_id, **kwargs)
945 def delete_brand_with_http_info(self, account_id, brand_id, **kwargs): 946 """ 947 Removes a brand. 948 This method deletes a brand from an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 949 This method makes a synchronous HTTP request by default. To make an 950 asynchronous HTTP request, please define a `callback` function 951 to be invoked when receiving the response. 952 >>> def callback_function(response): 953 >>> pprint(response) 954 >>> 955 >>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function) 956 957 :param callback function: The callback function 958 for asynchronous request. (optional) 959 :param str account_id: The external account number (int) or account ID Guid. (required) 960 :param str brand_id: The unique identifier of a brand. (required) 961 :return: None 962 If the method is called asynchronously, 963 returns the request thread. 964 """ 965 966 all_params = ['account_id', 'brand_id'] 967 all_params.append('callback') 968 all_params.append('_return_http_data_only') 969 all_params.append('_preload_content') 970 all_params.append('_request_timeout') 971 972 params = locals() 973 for key, val in iteritems(params['kwargs']): 974 if key not in all_params: 975 raise TypeError( 976 "Got an unexpected keyword argument '%s'" 977 " to method delete_brand" % key 978 ) 979 params[key] = val 980 del params['kwargs'] 981 # verify the required parameter 'account_id' is set 982 if ('account_id' not in params) or (params['account_id'] is None): 983 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand`") 984 # verify the required parameter 'brand_id' is set 985 if ('brand_id' not in params) or (params['brand_id'] is None): 986 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand`") 987 988 989 collection_formats = {} 990 991 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 992 path_params = {} 993 if 'account_id' in params: 994 path_params['accountId'] = params['account_id'] 995 if 'brand_id' in params: 996 path_params['brandId'] = params['brand_id'] 997 998 query_params = {} 999 1000 header_params = {} 1001 1002 form_params = [] 1003 local_var_files = {} 1004 1005 body_params = None 1006 # HTTP header `Accept` 1007 header_params['Accept'] = self.api_client.\ 1008 select_header_accept(['application/json']) 1009 1010 # Authentication setting 1011 auth_settings = [] 1012 1013 return self.api_client.call_api(resource_path, 'DELETE', 1014 path_params, 1015 query_params, 1016 header_params, 1017 body=body_params, 1018 post_params=form_params, 1019 files=local_var_files, 1020 response_type=None, 1021 auth_settings=auth_settings, 1022 callback=params.get('callback'), 1023 _return_http_data_only=params.get('_return_http_data_only'), 1024 _preload_content=params.get('_preload_content', True), 1025 _request_timeout=params.get('_request_timeout'), 1026 collection_formats=collection_formats)
Removes a brand.
This method deletes a brand from an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs)
1028 def delete_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 1029 """ 1030 Delete one branding logo. 1031 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1032 This method makes a synchronous HTTP request by default. To make an 1033 asynchronous HTTP request, please define a `callback` function 1034 to be invoked when receiving the response. 1035 >>> def callback_function(response): 1036 >>> pprint(response) 1037 >>> 1038 >>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 1039 1040 :param callback function: The callback function 1041 for asynchronous request. (optional) 1042 :param str account_id: The external account number (int) or account ID Guid. (required) 1043 :param str brand_id: The unique identifier of a brand. (required) 1044 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1045 :return: None 1046 If the method is called asynchronously, 1047 returns the request thread. 1048 """ 1049 kwargs['_return_http_data_only'] = True 1050 if kwargs.get('callback'): 1051 return self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1052 else: 1053 (data) = self.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 1054 return data
Delete one branding logo.
This method deletes a single logo from an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs)
1056 def delete_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 1057 """ 1058 Delete one branding logo. 1059 This method deletes a single logo from an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 1060 This method makes a synchronous HTTP request by default. To make an 1061 asynchronous HTTP request, please define a `callback` function 1062 to be invoked when receiving the response. 1063 >>> def callback_function(response): 1064 >>> pprint(response) 1065 >>> 1066 >>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 1067 1068 :param callback function: The callback function 1069 for asynchronous request. (optional) 1070 :param str account_id: The external account number (int) or account ID Guid. (required) 1071 :param str brand_id: The unique identifier of a brand. (required) 1072 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 1073 :return: None 1074 If the method is called asynchronously, 1075 returns the request thread. 1076 """ 1077 1078 all_params = ['account_id', 'brand_id', 'logo_type'] 1079 all_params.append('callback') 1080 all_params.append('_return_http_data_only') 1081 all_params.append('_preload_content') 1082 all_params.append('_request_timeout') 1083 1084 params = locals() 1085 for key, val in iteritems(params['kwargs']): 1086 if key not in all_params: 1087 raise TypeError( 1088 "Got an unexpected keyword argument '%s'" 1089 " to method delete_brand_logo_by_type" % key 1090 ) 1091 params[key] = val 1092 del params['kwargs'] 1093 # verify the required parameter 'account_id' is set 1094 if ('account_id' not in params) or (params['account_id'] is None): 1095 raise ValueError("Missing the required parameter `account_id` when calling `delete_brand_logo_by_type`") 1096 # verify the required parameter 'brand_id' is set 1097 if ('brand_id' not in params) or (params['brand_id'] is None): 1098 raise ValueError("Missing the required parameter `brand_id` when calling `delete_brand_logo_by_type`") 1099 # verify the required parameter 'logo_type' is set 1100 if ('logo_type' not in params) or (params['logo_type'] is None): 1101 raise ValueError("Missing the required parameter `logo_type` when calling `delete_brand_logo_by_type`") 1102 1103 1104 collection_formats = {} 1105 1106 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 1107 path_params = {} 1108 if 'account_id' in params: 1109 path_params['accountId'] = params['account_id'] 1110 if 'brand_id' in params: 1111 path_params['brandId'] = params['brand_id'] 1112 if 'logo_type' in params: 1113 path_params['logoType'] = params['logo_type'] 1114 1115 query_params = {} 1116 1117 header_params = {} 1118 1119 form_params = [] 1120 local_var_files = {} 1121 1122 body_params = None 1123 # HTTP header `Accept` 1124 header_params['Accept'] = self.api_client.\ 1125 select_header_accept(['application/json']) 1126 1127 # Authentication setting 1128 auth_settings = [] 1129 1130 return self.api_client.call_api(resource_path, 'DELETE', 1131 path_params, 1132 query_params, 1133 header_params, 1134 body=body_params, 1135 post_params=form_params, 1136 files=local_var_files, 1137 response_type=None, 1138 auth_settings=auth_settings, 1139 callback=params.get('callback'), 1140 _return_http_data_only=params.get('_return_http_data_only'), 1141 _preload_content=params.get('_preload_content', True), 1142 _request_timeout=params.get('_request_timeout'), 1143 collection_formats=collection_formats)
Delete one branding logo.
This method deletes a single logo from an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_brands(self, account_id, **kwargs)
1145 def delete_brands(self, account_id, **kwargs): 1146 """ 1147 Deletes one or more brand profiles. 1148 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1149 This method makes a synchronous HTTP request by default. To make an 1150 asynchronous HTTP request, please define a `callback` function 1151 to be invoked when receiving the response. 1152 >>> def callback_function(response): 1153 >>> pprint(response) 1154 >>> 1155 >>> thread = api.delete_brands(account_id, callback=callback_function) 1156 1157 :param callback function: The callback function 1158 for asynchronous request. (optional) 1159 :param str account_id: The external account number (int) or account ID Guid. (required) 1160 :param BrandsRequest brands_request: 1161 :return: BrandsResponse 1162 If the method is called asynchronously, 1163 returns the request thread. 1164 """ 1165 kwargs['_return_http_data_only'] = True 1166 if kwargs.get('callback'): 1167 return self.delete_brands_with_http_info(account_id, **kwargs) 1168 else: 1169 (data) = self.delete_brands_with_http_info(account_id, **kwargs) 1170 return data
Deletes one or more brand profiles.
Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true to use this call.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_brands(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- BrandsRequest brands_request:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
delete_brands_with_http_info(self, account_id, **kwargs)
1172 def delete_brands_with_http_info(self, account_id, **kwargs): 1173 """ 1174 Deletes one or more brand profiles. 1175 Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** to use this call. 1176 This method makes a synchronous HTTP request by default. To make an 1177 asynchronous HTTP request, please define a `callback` function 1178 to be invoked when receiving the response. 1179 >>> def callback_function(response): 1180 >>> pprint(response) 1181 >>> 1182 >>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function) 1183 1184 :param callback function: The callback function 1185 for asynchronous request. (optional) 1186 :param str account_id: The external account number (int) or account ID Guid. (required) 1187 :param BrandsRequest brands_request: 1188 :return: BrandsResponse 1189 If the method is called asynchronously, 1190 returns the request thread. 1191 """ 1192 1193 all_params = ['account_id', 'brands_request'] 1194 all_params.append('callback') 1195 all_params.append('_return_http_data_only') 1196 all_params.append('_preload_content') 1197 all_params.append('_request_timeout') 1198 1199 params = locals() 1200 for key, val in iteritems(params['kwargs']): 1201 if key not in all_params: 1202 raise TypeError( 1203 "Got an unexpected keyword argument '%s'" 1204 " to method delete_brands" % key 1205 ) 1206 params[key] = val 1207 del params['kwargs'] 1208 # verify the required parameter 'account_id' is set 1209 if ('account_id' not in params) or (params['account_id'] is None): 1210 raise ValueError("Missing the required parameter `account_id` when calling `delete_brands`") 1211 1212 1213 collection_formats = {} 1214 1215 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 1216 path_params = {} 1217 if 'account_id' in params: 1218 path_params['accountId'] = params['account_id'] 1219 1220 query_params = {} 1221 1222 header_params = {} 1223 1224 form_params = [] 1225 local_var_files = {} 1226 1227 body_params = None 1228 if 'brands_request' in params: 1229 body_params = params['brands_request'] 1230 # HTTP header `Accept` 1231 header_params['Accept'] = self.api_client.\ 1232 select_header_accept(['application/json']) 1233 1234 # Authentication setting 1235 auth_settings = [] 1236 1237 return self.api_client.call_api(resource_path, 'DELETE', 1238 path_params, 1239 query_params, 1240 header_params, 1241 body=body_params, 1242 post_params=form_params, 1243 files=local_var_files, 1244 response_type='BrandsResponse', 1245 auth_settings=auth_settings, 1246 callback=params.get('callback'), 1247 _return_http_data_only=params.get('_return_http_data_only'), 1248 _preload_content=params.get('_preload_content', True), 1249 _request_timeout=params.get('_request_timeout'), 1250 collection_formats=collection_formats)
Deletes one or more brand profiles.
Deletes one or more brand profiles from an account. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true to use this call.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_brands_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- BrandsRequest brands_request:
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
delete_captive_recipient(self, account_id, recipient_part, **kwargs)
1252 def delete_captive_recipient(self, account_id, recipient_part, **kwargs): 1253 """ 1254 Deletes the signature for one or more captive recipient records. 1255 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1256 This method makes a synchronous HTTP request by default. To make an 1257 asynchronous HTTP request, please define a `callback` function 1258 to be invoked when receiving the response. 1259 >>> def callback_function(response): 1260 >>> pprint(response) 1261 >>> 1262 >>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function) 1263 1264 :param callback function: The callback function 1265 for asynchronous request. (optional) 1266 :param str account_id: The external account number (int) or account ID Guid. (required) 1267 :param str recipient_part: (required) 1268 :param CaptiveRecipientInformation captive_recipient_information: 1269 :return: CaptiveRecipientInformation 1270 If the method is called asynchronously, 1271 returns the request thread. 1272 """ 1273 kwargs['_return_http_data_only'] = True 1274 if kwargs.get('callback'): 1275 return self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1276 else: 1277 (data) = self.delete_captive_recipient_with_http_info(account_id, recipient_part, **kwargs) 1278 return data
Deletes the signature for one or more captive recipient records.
Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_captive_recipient(account_id, recipient_part, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str recipient_part: (required)
- CaptiveRecipientInformation captive_recipient_information:
Returns
CaptiveRecipientInformation If the method is called asynchronously, returns the request thread.
def
delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs)
1280 def delete_captive_recipient_with_http_info(self, account_id, recipient_part, **kwargs): 1281 """ 1282 Deletes the signature for one or more captive recipient records. 1283 Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used. 1284 This method makes a synchronous HTTP request by default. To make an 1285 asynchronous HTTP request, please define a `callback` function 1286 to be invoked when receiving the response. 1287 >>> def callback_function(response): 1288 >>> pprint(response) 1289 >>> 1290 >>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function) 1291 1292 :param callback function: The callback function 1293 for asynchronous request. (optional) 1294 :param str account_id: The external account number (int) or account ID Guid. (required) 1295 :param str recipient_part: (required) 1296 :param CaptiveRecipientInformation captive_recipient_information: 1297 :return: CaptiveRecipientInformation 1298 If the method is called asynchronously, 1299 returns the request thread. 1300 """ 1301 1302 all_params = ['account_id', 'recipient_part', 'captive_recipient_information'] 1303 all_params.append('callback') 1304 all_params.append('_return_http_data_only') 1305 all_params.append('_preload_content') 1306 all_params.append('_request_timeout') 1307 1308 params = locals() 1309 for key, val in iteritems(params['kwargs']): 1310 if key not in all_params: 1311 raise TypeError( 1312 "Got an unexpected keyword argument '%s'" 1313 " to method delete_captive_recipient" % key 1314 ) 1315 params[key] = val 1316 del params['kwargs'] 1317 # verify the required parameter 'account_id' is set 1318 if ('account_id' not in params) or (params['account_id'] is None): 1319 raise ValueError("Missing the required parameter `account_id` when calling `delete_captive_recipient`") 1320 # verify the required parameter 'recipient_part' is set 1321 if ('recipient_part' not in params) or (params['recipient_part'] is None): 1322 raise ValueError("Missing the required parameter `recipient_part` when calling `delete_captive_recipient`") 1323 1324 1325 collection_formats = {} 1326 1327 resource_path = '/v2.1/accounts/{accountId}/captive_recipients/{recipientPart}'.replace('{format}', 'json') 1328 path_params = {} 1329 if 'account_id' in params: 1330 path_params['accountId'] = params['account_id'] 1331 if 'recipient_part' in params: 1332 path_params['recipientPart'] = params['recipient_part'] 1333 1334 query_params = {} 1335 1336 header_params = {} 1337 1338 form_params = [] 1339 local_var_files = {} 1340 1341 body_params = None 1342 if 'captive_recipient_information' in params: 1343 body_params = params['captive_recipient_information'] 1344 # HTTP header `Accept` 1345 header_params['Accept'] = self.api_client.\ 1346 select_header_accept(['application/json']) 1347 1348 # Authentication setting 1349 auth_settings = [] 1350 1351 return self.api_client.call_api(resource_path, 'DELETE', 1352 path_params, 1353 query_params, 1354 header_params, 1355 body=body_params, 1356 post_params=form_params, 1357 files=local_var_files, 1358 response_type='CaptiveRecipientInformation', 1359 auth_settings=auth_settings, 1360 callback=params.get('callback'), 1361 _return_http_data_only=params.get('_return_http_data_only'), 1362 _preload_content=params.get('_preload_content', True), 1363 _request_timeout=params.get('_request_timeout'), 1364 collection_formats=collection_formats)
Deletes the signature for one or more captive recipient records.
Deletes the signature for one or more captive recipient records; it is primarily used for testing. This provides a way to reset the signature associated with a client user ID so that a new signature can be created the next time the client user ID is used.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_captive_recipient_with_http_info(account_id, recipient_part, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str recipient_part: (required)
- CaptiveRecipientInformation captive_recipient_information:
Returns
CaptiveRecipientInformation If the method is called asynchronously, returns the request thread.
def
delete_custom_field(self, account_id, custom_field_id, **kwargs)
1366 def delete_custom_field(self, account_id, custom_field_id, **kwargs): 1367 """ 1368 Delete an existing account custom field. 1369 This method deletes an existing account custom field. 1370 This method makes a synchronous HTTP request by default. To make an 1371 asynchronous HTTP request, please define a `callback` function 1372 to be invoked when receiving the response. 1373 >>> def callback_function(response): 1374 >>> pprint(response) 1375 >>> 1376 >>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function) 1377 1378 :param callback function: The callback function 1379 for asynchronous request. (optional) 1380 :param str account_id: The external account number (int) or account ID Guid. (required) 1381 :param str custom_field_id: (required) 1382 :param str apply_to_templates: 1383 :return: None 1384 If the method is called asynchronously, 1385 returns the request thread. 1386 """ 1387 kwargs['_return_http_data_only'] = True 1388 if kwargs.get('callback'): 1389 return self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1390 else: 1391 (data) = self.delete_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 1392 return data
Delete an existing account custom field.
This method deletes an existing account custom field.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_custom_field(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs)
1394 def delete_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 1395 """ 1396 Delete an existing account custom field. 1397 This method deletes an existing account custom field. 1398 This method makes a synchronous HTTP request by default. To make an 1399 asynchronous HTTP request, please define a `callback` function 1400 to be invoked when receiving the response. 1401 >>> def callback_function(response): 1402 >>> pprint(response) 1403 >>> 1404 >>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 1405 1406 :param callback function: The callback function 1407 for asynchronous request. (optional) 1408 :param str account_id: The external account number (int) or account ID Guid. (required) 1409 :param str custom_field_id: (required) 1410 :param str apply_to_templates: 1411 :return: None 1412 If the method is called asynchronously, 1413 returns the request thread. 1414 """ 1415 1416 all_params = ['account_id', 'custom_field_id', 'apply_to_templates'] 1417 all_params.append('callback') 1418 all_params.append('_return_http_data_only') 1419 all_params.append('_preload_content') 1420 all_params.append('_request_timeout') 1421 1422 params = locals() 1423 for key, val in iteritems(params['kwargs']): 1424 if key not in all_params: 1425 raise TypeError( 1426 "Got an unexpected keyword argument '%s'" 1427 " to method delete_custom_field" % key 1428 ) 1429 params[key] = val 1430 del params['kwargs'] 1431 # verify the required parameter 'account_id' is set 1432 if ('account_id' not in params) or (params['account_id'] is None): 1433 raise ValueError("Missing the required parameter `account_id` when calling `delete_custom_field`") 1434 # verify the required parameter 'custom_field_id' is set 1435 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 1436 raise ValueError("Missing the required parameter `custom_field_id` when calling `delete_custom_field`") 1437 1438 1439 collection_formats = {} 1440 1441 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 1442 path_params = {} 1443 if 'account_id' in params: 1444 path_params['accountId'] = params['account_id'] 1445 if 'custom_field_id' in params: 1446 path_params['customFieldId'] = params['custom_field_id'] 1447 1448 query_params = {} 1449 if 'apply_to_templates' in params: 1450 query_params['apply_to_templates'] = params['apply_to_templates'] 1451 1452 header_params = {} 1453 1454 form_params = [] 1455 local_var_files = {} 1456 1457 body_params = None 1458 # HTTP header `Accept` 1459 header_params['Accept'] = self.api_client.\ 1460 select_header_accept(['application/json']) 1461 1462 # Authentication setting 1463 auth_settings = [] 1464 1465 return self.api_client.call_api(resource_path, 'DELETE', 1466 path_params, 1467 query_params, 1468 header_params, 1469 body=body_params, 1470 post_params=form_params, 1471 files=local_var_files, 1472 response_type=None, 1473 auth_settings=auth_settings, 1474 callback=params.get('callback'), 1475 _return_http_data_only=params.get('_return_http_data_only'), 1476 _preload_content=params.get('_preload_content', True), 1477 _request_timeout=params.get('_request_timeout'), 1478 collection_formats=collection_formats)
Delete an existing account custom field.
This method deletes an existing account custom field.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_e_note_configuration(self, account_id, **kwargs)
1480 def delete_e_note_configuration(self, account_id, **kwargs): 1481 """ 1482 Deletes configuration information for the eNote eOriginal integration. 1483 1484 This method makes a synchronous HTTP request by default. To make an 1485 asynchronous HTTP request, please define a `callback` function 1486 to be invoked when receiving the response. 1487 >>> def callback_function(response): 1488 >>> pprint(response) 1489 >>> 1490 >>> thread = api.delete_e_note_configuration(account_id, callback=callback_function) 1491 1492 :param callback function: The callback function 1493 for asynchronous request. (optional) 1494 :param str account_id: The external account number (int) or account ID Guid. (required) 1495 :return: None 1496 If the method is called asynchronously, 1497 returns the request thread. 1498 """ 1499 kwargs['_return_http_data_only'] = True 1500 if kwargs.get('callback'): 1501 return self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1502 else: 1503 (data) = self.delete_e_note_configuration_with_http_info(account_id, **kwargs) 1504 return data
Deletes configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_e_note_configuration(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_e_note_configuration_with_http_info(self, account_id, **kwargs)
1506 def delete_e_note_configuration_with_http_info(self, account_id, **kwargs): 1507 """ 1508 Deletes configuration information for the eNote eOriginal integration. 1509 1510 This method makes a synchronous HTTP request by default. To make an 1511 asynchronous HTTP request, please define a `callback` function 1512 to be invoked when receiving the response. 1513 >>> def callback_function(response): 1514 >>> pprint(response) 1515 >>> 1516 >>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function) 1517 1518 :param callback function: The callback function 1519 for asynchronous request. (optional) 1520 :param str account_id: The external account number (int) or account ID Guid. (required) 1521 :return: None 1522 If the method is called asynchronously, 1523 returns the request thread. 1524 """ 1525 1526 all_params = ['account_id'] 1527 all_params.append('callback') 1528 all_params.append('_return_http_data_only') 1529 all_params.append('_preload_content') 1530 all_params.append('_request_timeout') 1531 1532 params = locals() 1533 for key, val in iteritems(params['kwargs']): 1534 if key not in all_params: 1535 raise TypeError( 1536 "Got an unexpected keyword argument '%s'" 1537 " to method delete_e_note_configuration" % key 1538 ) 1539 params[key] = val 1540 del params['kwargs'] 1541 # verify the required parameter 'account_id' is set 1542 if ('account_id' not in params) or (params['account_id'] is None): 1543 raise ValueError("Missing the required parameter `account_id` when calling `delete_e_note_configuration`") 1544 1545 1546 collection_formats = {} 1547 1548 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 1549 path_params = {} 1550 if 'account_id' in params: 1551 path_params['accountId'] = params['account_id'] 1552 1553 query_params = {} 1554 1555 header_params = {} 1556 1557 form_params = [] 1558 local_var_files = {} 1559 1560 body_params = None 1561 # HTTP header `Accept` 1562 header_params['Accept'] = self.api_client.\ 1563 select_header_accept(['application/json']) 1564 1565 # Authentication setting 1566 auth_settings = [] 1567 1568 return self.api_client.call_api(resource_path, 'DELETE', 1569 path_params, 1570 query_params, 1571 header_params, 1572 body=body_params, 1573 post_params=form_params, 1574 files=local_var_files, 1575 response_type=None, 1576 auth_settings=auth_settings, 1577 callback=params.get('callback'), 1578 _return_http_data_only=params.get('_return_http_data_only'), 1579 _preload_content=params.get('_preload_content', True), 1580 _request_timeout=params.get('_request_timeout'), 1581 collection_formats=collection_formats)
Deletes configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_e_note_configuration_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_permission_profile(self, account_id, permission_profile_id, **kwargs)
1583 def delete_permission_profile(self, account_id, permission_profile_id, **kwargs): 1584 """ 1585 Deletes a permissions profile within the specified account. 1586 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1587 This method makes a synchronous HTTP request by default. To make an 1588 asynchronous HTTP request, please define a `callback` function 1589 to be invoked when receiving the response. 1590 >>> def callback_function(response): 1591 >>> pprint(response) 1592 >>> 1593 >>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function) 1594 1595 :param callback function: The callback function 1596 for asynchronous request. (optional) 1597 :param str account_id: The external account number (int) or account ID Guid. (required) 1598 :param str permission_profile_id: (required) 1599 :param str move_users_to: 1600 :return: None 1601 If the method is called asynchronously, 1602 returns the request thread. 1603 """ 1604 kwargs['_return_http_data_only'] = True 1605 if kwargs.get('callback'): 1606 return self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1607 else: 1608 (data) = self.delete_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 1609 return data
Deletes a permissions profile within the specified account.
This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the move_users_to query parameter. ### Related topics - How to delete a permission profile
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str move_users_to:
Returns
None If the method is called asynchronously, returns the request thread.
def
delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
1611 def delete_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 1612 """ 1613 Deletes a permissions profile within the specified account. 1614 This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the `move_users_to` query parameter. ### Related topics - [How to delete a permission profile](/docs/esign-rest-api/how-to/permission-profile-deleting/) 1615 This method makes a synchronous HTTP request by default. To make an 1616 asynchronous HTTP request, please define a `callback` function 1617 to be invoked when receiving the response. 1618 >>> def callback_function(response): 1619 >>> pprint(response) 1620 >>> 1621 >>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 1622 1623 :param callback function: The callback function 1624 for asynchronous request. (optional) 1625 :param str account_id: The external account number (int) or account ID Guid. (required) 1626 :param str permission_profile_id: (required) 1627 :param str move_users_to: 1628 :return: None 1629 If the method is called asynchronously, 1630 returns the request thread. 1631 """ 1632 1633 all_params = ['account_id', 'permission_profile_id', 'move_users_to'] 1634 all_params.append('callback') 1635 all_params.append('_return_http_data_only') 1636 all_params.append('_preload_content') 1637 all_params.append('_request_timeout') 1638 1639 params = locals() 1640 for key, val in iteritems(params['kwargs']): 1641 if key not in all_params: 1642 raise TypeError( 1643 "Got an unexpected keyword argument '%s'" 1644 " to method delete_permission_profile" % key 1645 ) 1646 params[key] = val 1647 del params['kwargs'] 1648 # verify the required parameter 'account_id' is set 1649 if ('account_id' not in params) or (params['account_id'] is None): 1650 raise ValueError("Missing the required parameter `account_id` when calling `delete_permission_profile`") 1651 # verify the required parameter 'permission_profile_id' is set 1652 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 1653 raise ValueError("Missing the required parameter `permission_profile_id` when calling `delete_permission_profile`") 1654 1655 1656 collection_formats = {} 1657 1658 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 1659 path_params = {} 1660 if 'account_id' in params: 1661 path_params['accountId'] = params['account_id'] 1662 if 'permission_profile_id' in params: 1663 path_params['permissionProfileId'] = params['permission_profile_id'] 1664 1665 query_params = {} 1666 if 'move_users_to' in params: 1667 query_params['move_users_to'] = params['move_users_to'] 1668 1669 header_params = {} 1670 1671 form_params = [] 1672 local_var_files = {} 1673 1674 body_params = None 1675 # HTTP header `Accept` 1676 header_params['Accept'] = self.api_client.\ 1677 select_header_accept(['application/json']) 1678 1679 # Authentication setting 1680 auth_settings = [] 1681 1682 return self.api_client.call_api(resource_path, 'DELETE', 1683 path_params, 1684 query_params, 1685 header_params, 1686 body=body_params, 1687 post_params=form_params, 1688 files=local_var_files, 1689 response_type=None, 1690 auth_settings=auth_settings, 1691 callback=params.get('callback'), 1692 _return_http_data_only=params.get('_return_http_data_only'), 1693 _preload_content=params.get('_preload_content', True), 1694 _request_timeout=params.get('_request_timeout'), 1695 collection_formats=collection_formats)
Deletes a permissions profile within the specified account.
This method deletes a permission profile from an account. To delete a permission profile, it must not have any users associated with it. When you use this method to delete a permission profile, you can reassign the users associated with it to a new permission profile at the same time by using the move_users_to query parameter. ### Related topics - How to delete a permission profile
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.delete_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str move_users_to:
Returns
None If the method is called asynchronously, returns the request thread.
def
get_account_identity_verification(self, account_id, **kwargs)
1697 def get_account_identity_verification(self, account_id, **kwargs): 1698 """ 1699 Get the list of identity verification options for an account 1700 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 1701 This method makes a synchronous HTTP request by default. To make an 1702 asynchronous HTTP request, please define a `callback` function 1703 to be invoked when receiving the response. 1704 >>> def callback_function(response): 1705 >>> pprint(response) 1706 >>> 1707 >>> thread = api.get_account_identity_verification(account_id, callback=callback_function) 1708 1709 :param callback function: The callback function 1710 for asynchronous request. (optional) 1711 :param str account_id: The external account number (int) or account ID Guid. (required) 1712 :return: AccountIdentityVerificationResponse 1713 If the method is called asynchronously, 1714 returns the request thread. 1715 """ 1716 kwargs['_return_http_data_only'] = True 1717 if kwargs.get('callback'): 1718 return self.get_account_identity_verification_with_http_info(account_id, **kwargs) 1719 else: 1720 (data) = self.get_account_identity_verification_with_http_info(account_id, **kwargs) 1721 return data
Get the list of identity verification options for an account
This method returns a list of Identity Verification workflows that are available to an account. Note: To use this method, you must either be an account administrator or a sender. ### Related topics - How to require ID Verification (IDV) for a recipient
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_identity_verification(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.
def
get_account_identity_verification_with_http_info(self, account_id, **kwargs)
1723 def get_account_identity_verification_with_http_info(self, account_id, **kwargs): 1724 """ 1725 Get the list of identity verification options for an account 1726 This method returns a list of Identity Verification workflows that are available to an account. **Note:** To use this method, you must either be an account administrator or a sender. ### Related topics - [How to require ID Verification (IDV) for a recipient](/docs/esign-rest-api/how-to/id-verification/) 1727 This method makes a synchronous HTTP request by default. To make an 1728 asynchronous HTTP request, please define a `callback` function 1729 to be invoked when receiving the response. 1730 >>> def callback_function(response): 1731 >>> pprint(response) 1732 >>> 1733 >>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function) 1734 1735 :param callback function: The callback function 1736 for asynchronous request. (optional) 1737 :param str account_id: The external account number (int) or account ID Guid. (required) 1738 :return: AccountIdentityVerificationResponse 1739 If the method is called asynchronously, 1740 returns the request thread. 1741 """ 1742 1743 all_params = ['account_id'] 1744 all_params.append('callback') 1745 all_params.append('_return_http_data_only') 1746 all_params.append('_preload_content') 1747 all_params.append('_request_timeout') 1748 1749 params = locals() 1750 for key, val in iteritems(params['kwargs']): 1751 if key not in all_params: 1752 raise TypeError( 1753 "Got an unexpected keyword argument '%s'" 1754 " to method get_account_identity_verification" % key 1755 ) 1756 params[key] = val 1757 del params['kwargs'] 1758 # verify the required parameter 'account_id' is set 1759 if ('account_id' not in params) or (params['account_id'] is None): 1760 raise ValueError("Missing the required parameter `account_id` when calling `get_account_identity_verification`") 1761 1762 1763 collection_formats = {} 1764 1765 resource_path = '/v2.1/accounts/{accountId}/identity_verification'.replace('{format}', 'json') 1766 path_params = {} 1767 if 'account_id' in params: 1768 path_params['accountId'] = params['account_id'] 1769 1770 query_params = {} 1771 1772 header_params = {} 1773 1774 form_params = [] 1775 local_var_files = {} 1776 1777 body_params = None 1778 # HTTP header `Accept` 1779 header_params['Accept'] = self.api_client.\ 1780 select_header_accept(['application/json']) 1781 1782 # Authentication setting 1783 auth_settings = [] 1784 1785 return self.api_client.call_api(resource_path, 'GET', 1786 path_params, 1787 query_params, 1788 header_params, 1789 body=body_params, 1790 post_params=form_params, 1791 files=local_var_files, 1792 response_type='AccountIdentityVerificationResponse', 1793 auth_settings=auth_settings, 1794 callback=params.get('callback'), 1795 _return_http_data_only=params.get('_return_http_data_only'), 1796 _preload_content=params.get('_preload_content', True), 1797 _request_timeout=params.get('_request_timeout'), 1798 collection_formats=collection_formats)
Get the list of identity verification options for an account
This method returns a list of Identity Verification workflows that are available to an account. Note: To use this method, you must either be an account administrator or a sender. ### Related topics - How to require ID Verification (IDV) for a recipient
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_identity_verification_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountIdentityVerificationResponse If the method is called asynchronously, returns the request thread.
def
get_account_information(self, account_id, **kwargs)
1800 def get_account_information(self, account_id, **kwargs): 1801 """ 1802 Retrieves the account information for the specified account. 1803 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 1804 This method makes a synchronous HTTP request by default. To make an 1805 asynchronous HTTP request, please define a `callback` function 1806 to be invoked when receiving the response. 1807 >>> def callback_function(response): 1808 >>> pprint(response) 1809 >>> 1810 >>> thread = api.get_account_information(account_id, callback=callback_function) 1811 1812 :param callback function: The callback function 1813 for asynchronous request. (optional) 1814 :param str account_id: The external account number (int) or account ID Guid. (required) 1815 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 1816 :return: AccountInformation 1817 If the method is called asynchronously, 1818 returns the request thread. 1819 """ 1820 kwargs['_return_http_data_only'] = True 1821 if kwargs.get('callback'): 1822 return self.get_account_information_with_http_info(account_id, **kwargs) 1823 else: 1824 (data) = self.get_account_information_with_http_info(account_id, **kwargs) 1825 return data
Retrieves the account information for the specified account.
Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the API.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_information(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include_account_settings: When set to true, includes the account settings for the account in the response.
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_information_with_http_info(self, account_id, **kwargs)
1827 def get_account_information_with_http_info(self, account_id, **kwargs): 1828 """ 1829 Retrieves the account information for the specified account. 1830 Retrieves the account information for the specified account. **Response** The `canUpgrade` property contains is a Boolean that indicates whether the account can be upgraded through the API. 1831 This method makes a synchronous HTTP request by default. To make an 1832 asynchronous HTTP request, please define a `callback` function 1833 to be invoked when receiving the response. 1834 >>> def callback_function(response): 1835 >>> pprint(response) 1836 >>> 1837 >>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function) 1838 1839 :param callback function: The callback function 1840 for asynchronous request. (optional) 1841 :param str account_id: The external account number (int) or account ID Guid. (required) 1842 :param str include_account_settings: When set to **true**, includes the account settings for the account in the response. 1843 :return: AccountInformation 1844 If the method is called asynchronously, 1845 returns the request thread. 1846 """ 1847 1848 all_params = ['account_id', 'include_account_settings'] 1849 all_params.append('callback') 1850 all_params.append('_return_http_data_only') 1851 all_params.append('_preload_content') 1852 all_params.append('_request_timeout') 1853 1854 params = locals() 1855 for key, val in iteritems(params['kwargs']): 1856 if key not in all_params: 1857 raise TypeError( 1858 "Got an unexpected keyword argument '%s'" 1859 " to method get_account_information" % key 1860 ) 1861 params[key] = val 1862 del params['kwargs'] 1863 # verify the required parameter 'account_id' is set 1864 if ('account_id' not in params) or (params['account_id'] is None): 1865 raise ValueError("Missing the required parameter `account_id` when calling `get_account_information`") 1866 1867 1868 collection_formats = {} 1869 1870 resource_path = '/v2.1/accounts/{accountId}'.replace('{format}', 'json') 1871 path_params = {} 1872 if 'account_id' in params: 1873 path_params['accountId'] = params['account_id'] 1874 1875 query_params = {} 1876 if 'include_account_settings' in params: 1877 query_params['include_account_settings'] = params['include_account_settings'] 1878 1879 header_params = {} 1880 1881 form_params = [] 1882 local_var_files = {} 1883 1884 body_params = None 1885 # HTTP header `Accept` 1886 header_params['Accept'] = self.api_client.\ 1887 select_header_accept(['application/json']) 1888 1889 # Authentication setting 1890 auth_settings = [] 1891 1892 return self.api_client.call_api(resource_path, 'GET', 1893 path_params, 1894 query_params, 1895 header_params, 1896 body=body_params, 1897 post_params=form_params, 1898 files=local_var_files, 1899 response_type='AccountInformation', 1900 auth_settings=auth_settings, 1901 callback=params.get('callback'), 1902 _return_http_data_only=params.get('_return_http_data_only'), 1903 _preload_content=params.get('_preload_content', True), 1904 _request_timeout=params.get('_request_timeout'), 1905 collection_formats=collection_formats)
Retrieves the account information for the specified account.
Retrieves the account information for the specified account. Response The canUpgrade property contains is a Boolean that indicates whether the account can be upgraded through the API.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_information_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include_account_settings: When set to true, includes the account settings for the account in the response.
Returns
AccountInformation If the method is called asynchronously, returns the request thread.
def
get_account_signature(self, account_id, signature_id, **kwargs)
1907 def get_account_signature(self, account_id, signature_id, **kwargs): 1908 """ 1909 Returns information about a single signature by specifed signatureId. 1910 1911 This method makes a synchronous HTTP request by default. To make an 1912 asynchronous HTTP request, please define a `callback` function 1913 to be invoked when receiving the response. 1914 >>> def callback_function(response): 1915 >>> pprint(response) 1916 >>> 1917 >>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function) 1918 1919 :param callback function: The callback function 1920 for asynchronous request. (optional) 1921 :param str account_id: The external account number (int) or account ID Guid. (required) 1922 :param str signature_id: The ID of the signature being accessed. (required) 1923 :return: AccountSignature 1924 If the method is called asynchronously, 1925 returns the request thread. 1926 """ 1927 kwargs['_return_http_data_only'] = True 1928 if kwargs.get('callback'): 1929 return self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 1930 else: 1931 (data) = self.get_account_signature_with_http_info(account_id, signature_id, **kwargs) 1932 return data
Returns information about a single signature by specifed signatureId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_signature(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
get_account_signature_with_http_info(self, account_id, signature_id, **kwargs)
1934 def get_account_signature_with_http_info(self, account_id, signature_id, **kwargs): 1935 """ 1936 Returns information about a single signature by specifed signatureId. 1937 1938 This method makes a synchronous HTTP request by default. To make an 1939 asynchronous HTTP request, please define a `callback` function 1940 to be invoked when receiving the response. 1941 >>> def callback_function(response): 1942 >>> pprint(response) 1943 >>> 1944 >>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function) 1945 1946 :param callback function: The callback function 1947 for asynchronous request. (optional) 1948 :param str account_id: The external account number (int) or account ID Guid. (required) 1949 :param str signature_id: The ID of the signature being accessed. (required) 1950 :return: AccountSignature 1951 If the method is called asynchronously, 1952 returns the request thread. 1953 """ 1954 1955 all_params = ['account_id', 'signature_id'] 1956 all_params.append('callback') 1957 all_params.append('_return_http_data_only') 1958 all_params.append('_preload_content') 1959 all_params.append('_request_timeout') 1960 1961 params = locals() 1962 for key, val in iteritems(params['kwargs']): 1963 if key not in all_params: 1964 raise TypeError( 1965 "Got an unexpected keyword argument '%s'" 1966 " to method get_account_signature" % key 1967 ) 1968 params[key] = val 1969 del params['kwargs'] 1970 # verify the required parameter 'account_id' is set 1971 if ('account_id' not in params) or (params['account_id'] is None): 1972 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature`") 1973 # verify the required parameter 'signature_id' is set 1974 if ('signature_id' not in params) or (params['signature_id'] is None): 1975 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature`") 1976 1977 1978 collection_formats = {} 1979 1980 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 1981 path_params = {} 1982 if 'account_id' in params: 1983 path_params['accountId'] = params['account_id'] 1984 if 'signature_id' in params: 1985 path_params['signatureId'] = params['signature_id'] 1986 1987 query_params = {} 1988 1989 header_params = {} 1990 1991 form_params = [] 1992 local_var_files = {} 1993 1994 body_params = None 1995 # HTTP header `Accept` 1996 header_params['Accept'] = self.api_client.\ 1997 select_header_accept(['application/json']) 1998 1999 # Authentication setting 2000 auth_settings = [] 2001 2002 return self.api_client.call_api(resource_path, 'GET', 2003 path_params, 2004 query_params, 2005 header_params, 2006 body=body_params, 2007 post_params=form_params, 2008 files=local_var_files, 2009 response_type='AccountSignature', 2010 auth_settings=auth_settings, 2011 callback=params.get('callback'), 2012 _return_http_data_only=params.get('_return_http_data_only'), 2013 _preload_content=params.get('_preload_content', True), 2014 _request_timeout=params.get('_request_timeout'), 2015 collection_formats=collection_formats)
Returns information about a single signature by specifed signatureId.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_signature_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
get_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
2017 def get_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 2018 """ 2019 Returns a signature, initials, or stamps image. 2020 2021 This method makes a synchronous HTTP request by default. To make an 2022 asynchronous HTTP request, please define a `callback` function 2023 to be invoked when receiving the response. 2024 >>> def callback_function(response): 2025 >>> pprint(response) 2026 >>> 2027 >>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 2028 2029 :param callback function: The callback function 2030 for asynchronous request. (optional) 2031 :param str account_id: The external account number (int) or account ID Guid. (required) 2032 :param str image_type: One of **signature_image** or **initials_image**. (required) 2033 :param str signature_id: The ID of the signature being accessed. (required) 2034 :param str include_chrome: 2035 :return: file 2036 If the method is called asynchronously, 2037 returns the request thread. 2038 """ 2039 kwargs['_return_http_data_only'] = True 2040 if kwargs.get('callback'): 2041 return self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2042 else: 2043 (data) = self.get_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 2044 return data
Returns a signature, initials, or stamps image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str include_chrome:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
2046 def get_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 2047 """ 2048 Returns a signature, initials, or stamps image. 2049 2050 This method makes a synchronous HTTP request by default. To make an 2051 asynchronous HTTP request, please define a `callback` function 2052 to be invoked when receiving the response. 2053 >>> def callback_function(response): 2054 >>> pprint(response) 2055 >>> 2056 >>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 2057 2058 :param callback function: The callback function 2059 for asynchronous request. (optional) 2060 :param str account_id: The external account number (int) or account ID Guid. (required) 2061 :param str image_type: One of **signature_image** or **initials_image**. (required) 2062 :param str signature_id: The ID of the signature being accessed. (required) 2063 :param str include_chrome: 2064 :return: file 2065 If the method is called asynchronously, 2066 returns the request thread. 2067 """ 2068 2069 all_params = ['account_id', 'image_type', 'signature_id', 'include_chrome'] 2070 all_params.append('callback') 2071 all_params.append('_return_http_data_only') 2072 all_params.append('_preload_content') 2073 all_params.append('_request_timeout') 2074 2075 params = locals() 2076 for key, val in iteritems(params['kwargs']): 2077 if key not in all_params: 2078 raise TypeError( 2079 "Got an unexpected keyword argument '%s'" 2080 " to method get_account_signature_image" % key 2081 ) 2082 params[key] = val 2083 del params['kwargs'] 2084 # verify the required parameter 'account_id' is set 2085 if ('account_id' not in params) or (params['account_id'] is None): 2086 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signature_image`") 2087 # verify the required parameter 'image_type' is set 2088 if ('image_type' not in params) or (params['image_type'] is None): 2089 raise ValueError("Missing the required parameter `image_type` when calling `get_account_signature_image`") 2090 # verify the required parameter 'signature_id' is set 2091 if ('signature_id' not in params) or (params['signature_id'] is None): 2092 raise ValueError("Missing the required parameter `signature_id` when calling `get_account_signature_image`") 2093 2094 2095 collection_formats = {} 2096 2097 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 2098 path_params = {} 2099 if 'account_id' in params: 2100 path_params['accountId'] = params['account_id'] 2101 if 'image_type' in params: 2102 path_params['imageType'] = params['image_type'] 2103 if 'signature_id' in params: 2104 path_params['signatureId'] = params['signature_id'] 2105 2106 query_params = {} 2107 if 'include_chrome' in params: 2108 query_params['include_chrome'] = params['include_chrome'] 2109 2110 header_params = {} 2111 2112 form_params = [] 2113 local_var_files = {} 2114 2115 body_params = None 2116 # HTTP header `Accept` 2117 header_params['Accept'] = self.api_client.\ 2118 select_header_accept(['image/gif']) 2119 2120 # Authentication setting 2121 auth_settings = [] 2122 2123 return self.api_client.call_api(resource_path, 'GET', 2124 path_params, 2125 query_params, 2126 header_params, 2127 body=body_params, 2128 post_params=form_params, 2129 files=local_var_files, 2130 response_type='file', 2131 auth_settings=auth_settings, 2132 callback=params.get('callback'), 2133 _return_http_data_only=params.get('_return_http_data_only'), 2134 _preload_content=params.get('_preload_content', True), 2135 _request_timeout=params.get('_request_timeout'), 2136 collection_formats=collection_formats)
Returns a signature, initials, or stamps image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str include_chrome:
Returns
file If the method is called asynchronously, returns the request thread.
def
get_account_signatures(self, account_id, **kwargs)
2138 def get_account_signatures(self, account_id, **kwargs): 2139 """ 2140 Returns the managed signature definitions for the account 2141 2142 This method makes a synchronous HTTP request by default. To make an 2143 asynchronous HTTP request, please define a `callback` function 2144 to be invoked when receiving the response. 2145 >>> def callback_function(response): 2146 >>> pprint(response) 2147 >>> 2148 >>> thread = api.get_account_signatures(account_id, callback=callback_function) 2149 2150 :param callback function: The callback function 2151 for asynchronous request. (optional) 2152 :param str account_id: The external account number (int) or account ID Guid. (required) 2153 :param str stamp_format: 2154 :param str stamp_name: 2155 :param str stamp_type: 2156 :return: AccountSignaturesInformation 2157 If the method is called asynchronously, 2158 returns the request thread. 2159 """ 2160 kwargs['_return_http_data_only'] = True 2161 if kwargs.get('callback'): 2162 return self.get_account_signatures_with_http_info(account_id, **kwargs) 2163 else: 2164 (data) = self.get_account_signatures_with_http_info(account_id, **kwargs) 2165 return data
Returns the managed signature definitions for the account
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_signatures(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str stamp_format:
- str stamp_name:
- str stamp_type:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
get_account_signatures_with_http_info(self, account_id, **kwargs)
2167 def get_account_signatures_with_http_info(self, account_id, **kwargs): 2168 """ 2169 Returns the managed signature definitions for the account 2170 2171 This method makes a synchronous HTTP request by default. To make an 2172 asynchronous HTTP request, please define a `callback` function 2173 to be invoked when receiving the response. 2174 >>> def callback_function(response): 2175 >>> pprint(response) 2176 >>> 2177 >>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function) 2178 2179 :param callback function: The callback function 2180 for asynchronous request. (optional) 2181 :param str account_id: The external account number (int) or account ID Guid. (required) 2182 :param str stamp_format: 2183 :param str stamp_name: 2184 :param str stamp_type: 2185 :return: AccountSignaturesInformation 2186 If the method is called asynchronously, 2187 returns the request thread. 2188 """ 2189 2190 all_params = ['account_id', 'stamp_format', 'stamp_name', 'stamp_type'] 2191 all_params.append('callback') 2192 all_params.append('_return_http_data_only') 2193 all_params.append('_preload_content') 2194 all_params.append('_request_timeout') 2195 2196 params = locals() 2197 for key, val in iteritems(params['kwargs']): 2198 if key not in all_params: 2199 raise TypeError( 2200 "Got an unexpected keyword argument '%s'" 2201 " to method get_account_signatures" % key 2202 ) 2203 params[key] = val 2204 del params['kwargs'] 2205 # verify the required parameter 'account_id' is set 2206 if ('account_id' not in params) or (params['account_id'] is None): 2207 raise ValueError("Missing the required parameter `account_id` when calling `get_account_signatures`") 2208 2209 2210 collection_formats = {} 2211 2212 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 2213 path_params = {} 2214 if 'account_id' in params: 2215 path_params['accountId'] = params['account_id'] 2216 2217 query_params = {} 2218 if 'stamp_format' in params: 2219 query_params['stamp_format'] = params['stamp_format'] 2220 if 'stamp_name' in params: 2221 query_params['stamp_name'] = params['stamp_name'] 2222 if 'stamp_type' in params: 2223 query_params['stamp_type'] = params['stamp_type'] 2224 2225 header_params = {} 2226 2227 form_params = [] 2228 local_var_files = {} 2229 2230 body_params = None 2231 # HTTP header `Accept` 2232 header_params['Accept'] = self.api_client.\ 2233 select_header_accept(['application/json']) 2234 2235 # Authentication setting 2236 auth_settings = [] 2237 2238 return self.api_client.call_api(resource_path, 'GET', 2239 path_params, 2240 query_params, 2241 header_params, 2242 body=body_params, 2243 post_params=form_params, 2244 files=local_var_files, 2245 response_type='AccountSignaturesInformation', 2246 auth_settings=auth_settings, 2247 callback=params.get('callback'), 2248 _return_http_data_only=params.get('_return_http_data_only'), 2249 _preload_content=params.get('_preload_content', True), 2250 _request_timeout=params.get('_request_timeout'), 2251 collection_formats=collection_formats)
Returns the managed signature definitions for the account
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_signatures_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str stamp_format:
- str stamp_name:
- str stamp_type:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
get_account_tab_settings(self, account_id, **kwargs)
2253 def get_account_tab_settings(self, account_id, **kwargs): 2254 """ 2255 Returns tab settings list for specified account 2256 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2257 This method makes a synchronous HTTP request by default. To make an 2258 asynchronous HTTP request, please define a `callback` function 2259 to be invoked when receiving the response. 2260 >>> def callback_function(response): 2261 >>> pprint(response) 2262 >>> 2263 >>> thread = api.get_account_tab_settings(account_id, callback=callback_function) 2264 2265 :param callback function: The callback function 2266 for asynchronous request. (optional) 2267 :param str account_id: The external account number (int) or account ID Guid. (required) 2268 :return: TabAccountSettings 2269 If the method is called asynchronously, 2270 returns the request thread. 2271 """ 2272 kwargs['_return_http_data_only'] = True 2273 if kwargs.get('callback'): 2274 return self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2275 else: 2276 (data) = self.get_account_tab_settings_with_http_info(account_id, **kwargs) 2277 return data
Returns tab settings list for specified account
This method returns information about the tab types and tab functionality that is currently enabled for an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_tab_settings(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
get_account_tab_settings_with_http_info(self, account_id, **kwargs)
2279 def get_account_tab_settings_with_http_info(self, account_id, **kwargs): 2280 """ 2281 Returns tab settings list for specified account 2282 This method returns information about the tab types and tab functionality that is currently enabled for an account. 2283 This method makes a synchronous HTTP request by default. To make an 2284 asynchronous HTTP request, please define a `callback` function 2285 to be invoked when receiving the response. 2286 >>> def callback_function(response): 2287 >>> pprint(response) 2288 >>> 2289 >>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function) 2290 2291 :param callback function: The callback function 2292 for asynchronous request. (optional) 2293 :param str account_id: The external account number (int) or account ID Guid. (required) 2294 :return: TabAccountSettings 2295 If the method is called asynchronously, 2296 returns the request thread. 2297 """ 2298 2299 all_params = ['account_id'] 2300 all_params.append('callback') 2301 all_params.append('_return_http_data_only') 2302 all_params.append('_preload_content') 2303 all_params.append('_request_timeout') 2304 2305 params = locals() 2306 for key, val in iteritems(params['kwargs']): 2307 if key not in all_params: 2308 raise TypeError( 2309 "Got an unexpected keyword argument '%s'" 2310 " to method get_account_tab_settings" % key 2311 ) 2312 params[key] = val 2313 del params['kwargs'] 2314 # verify the required parameter 'account_id' is set 2315 if ('account_id' not in params) or (params['account_id'] is None): 2316 raise ValueError("Missing the required parameter `account_id` when calling `get_account_tab_settings`") 2317 2318 2319 collection_formats = {} 2320 2321 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 2322 path_params = {} 2323 if 'account_id' in params: 2324 path_params['accountId'] = params['account_id'] 2325 2326 query_params = {} 2327 2328 header_params = {} 2329 2330 form_params = [] 2331 local_var_files = {} 2332 2333 body_params = None 2334 # HTTP header `Accept` 2335 header_params['Accept'] = self.api_client.\ 2336 select_header_accept(['application/json']) 2337 2338 # Authentication setting 2339 auth_settings = [] 2340 2341 return self.api_client.call_api(resource_path, 'GET', 2342 path_params, 2343 query_params, 2344 header_params, 2345 body=body_params, 2346 post_params=form_params, 2347 files=local_var_files, 2348 response_type='TabAccountSettings', 2349 auth_settings=auth_settings, 2350 callback=params.get('callback'), 2351 _return_http_data_only=params.get('_return_http_data_only'), 2352 _preload_content=params.get('_preload_content', True), 2353 _request_timeout=params.get('_request_timeout'), 2354 collection_formats=collection_formats)
Returns tab settings list for specified account
This method returns information about the tab types and tab functionality that is currently enabled for an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_account_tab_settings_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
get_all_payment_gateway_accounts(self, account_id, **kwargs)
2356 def get_all_payment_gateway_accounts(self, account_id, **kwargs): 2357 """ 2358 Get all payment gateway account for the provided accountId 2359 This method returns a list of payment gateway accounts and basic information about them. 2360 This method makes a synchronous HTTP request by default. To make an 2361 asynchronous HTTP request, please define a `callback` function 2362 to be invoked when receiving the response. 2363 >>> def callback_function(response): 2364 >>> pprint(response) 2365 >>> 2366 >>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function) 2367 2368 :param callback function: The callback function 2369 for asynchronous request. (optional) 2370 :param str account_id: The external account number (int) or account ID Guid. (required) 2371 :return: PaymentGatewayAccountsInfo 2372 If the method is called asynchronously, 2373 returns the request thread. 2374 """ 2375 kwargs['_return_http_data_only'] = True 2376 if kwargs.get('callback'): 2377 return self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2378 else: 2379 (data) = self.get_all_payment_gateway_accounts_with_http_info(account_id, **kwargs) 2380 return data
Get all payment gateway account for the provided accountId
This method returns a list of payment gateway accounts and basic information about them.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_all_payment_gateway_accounts(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
PaymentGatewayAccountsInfo If the method is called asynchronously, returns the request thread.
def
get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs)
2382 def get_all_payment_gateway_accounts_with_http_info(self, account_id, **kwargs): 2383 """ 2384 Get all payment gateway account for the provided accountId 2385 This method returns a list of payment gateway accounts and basic information about them. 2386 This method makes a synchronous HTTP request by default. To make an 2387 asynchronous HTTP request, please define a `callback` function 2388 to be invoked when receiving the response. 2389 >>> def callback_function(response): 2390 >>> pprint(response) 2391 >>> 2392 >>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function) 2393 2394 :param callback function: The callback function 2395 for asynchronous request. (optional) 2396 :param str account_id: The external account number (int) or account ID Guid. (required) 2397 :return: PaymentGatewayAccountsInfo 2398 If the method is called asynchronously, 2399 returns the request thread. 2400 """ 2401 2402 all_params = ['account_id'] 2403 all_params.append('callback') 2404 all_params.append('_return_http_data_only') 2405 all_params.append('_preload_content') 2406 all_params.append('_request_timeout') 2407 2408 params = locals() 2409 for key, val in iteritems(params['kwargs']): 2410 if key not in all_params: 2411 raise TypeError( 2412 "Got an unexpected keyword argument '%s'" 2413 " to method get_all_payment_gateway_accounts" % key 2414 ) 2415 params[key] = val 2416 del params['kwargs'] 2417 # verify the required parameter 'account_id' is set 2418 if ('account_id' not in params) or (params['account_id'] is None): 2419 raise ValueError("Missing the required parameter `account_id` when calling `get_all_payment_gateway_accounts`") 2420 2421 2422 collection_formats = {} 2423 2424 resource_path = '/v2.1/accounts/{accountId}/payment_gateway_accounts'.replace('{format}', 'json') 2425 path_params = {} 2426 if 'account_id' in params: 2427 path_params['accountId'] = params['account_id'] 2428 2429 query_params = {} 2430 2431 header_params = {} 2432 2433 form_params = [] 2434 local_var_files = {} 2435 2436 body_params = None 2437 # HTTP header `Accept` 2438 header_params['Accept'] = self.api_client.\ 2439 select_header_accept(['application/json']) 2440 2441 # Authentication setting 2442 auth_settings = [] 2443 2444 return self.api_client.call_api(resource_path, 'GET', 2445 path_params, 2446 query_params, 2447 header_params, 2448 body=body_params, 2449 post_params=form_params, 2450 files=local_var_files, 2451 response_type='PaymentGatewayAccountsInfo', 2452 auth_settings=auth_settings, 2453 callback=params.get('callback'), 2454 _return_http_data_only=params.get('_return_http_data_only'), 2455 _preload_content=params.get('_preload_content', True), 2456 _request_timeout=params.get('_request_timeout'), 2457 collection_formats=collection_formats)
Get all payment gateway account for the provided accountId
This method returns a list of payment gateway accounts and basic information about them.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_all_payment_gateway_accounts_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
PaymentGatewayAccountsInfo If the method is called asynchronously, returns the request thread.
def
get_billing_charges(self, account_id, **kwargs)
2459 def get_billing_charges(self, account_id, **kwargs): 2460 """ 2461 Gets list of recurring and usage charges for the account. 2462 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 2463 This method makes a synchronous HTTP request by default. To make an 2464 asynchronous HTTP request, please define a `callback` function 2465 to be invoked when receiving the response. 2466 >>> def callback_function(response): 2467 >>> pprint(response) 2468 >>> 2469 >>> thread = api.get_billing_charges(account_id, callback=callback_function) 2470 2471 :param callback function: The callback function 2472 for asynchronous request. (optional) 2473 :param str account_id: The external account number (int) or account ID Guid. (required) 2474 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 2475 :return: BillingChargeResponse 2476 If the method is called asynchronously, 2477 returns the request thread. 2478 """ 2479 kwargs['_return_http_data_only'] = True 2480 if kwargs.get('callback'): 2481 return self.get_billing_charges_with_http_info(account_id, **kwargs) 2482 else: 2483 (data) = self.get_billing_charges_with_http_info(account_id, **kwargs) 2484 return data
Gets list of recurring and usage charges for the account.
Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_billing_charges(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats
Returns
BillingChargeResponse If the method is called asynchronously, returns the request thread.
def
get_billing_charges_with_http_info(self, account_id, **kwargs)
2486 def get_billing_charges_with_http_info(self, account_id, **kwargs): 2487 """ 2488 Gets list of recurring and usage charges for the account. 2489 Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator 2490 This method makes a synchronous HTTP request by default. To make an 2491 asynchronous HTTP request, please define a `callback` function 2492 to be invoked when receiving the response. 2493 >>> def callback_function(response): 2494 >>> pprint(response) 2495 >>> 2496 >>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function) 2497 2498 :param callback function: The callback function 2499 for asynchronous request. (optional) 2500 :param str account_id: The external account number (int) or account ID Guid. (required) 2501 :param str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats 2502 :return: BillingChargeResponse 2503 If the method is called asynchronously, 2504 returns the request thread. 2505 """ 2506 2507 all_params = ['account_id', 'include_charges'] 2508 all_params.append('callback') 2509 all_params.append('_return_http_data_only') 2510 all_params.append('_preload_content') 2511 all_params.append('_request_timeout') 2512 2513 params = locals() 2514 for key, val in iteritems(params['kwargs']): 2515 if key not in all_params: 2516 raise TypeError( 2517 "Got an unexpected keyword argument '%s'" 2518 " to method get_billing_charges" % key 2519 ) 2520 params[key] = val 2521 del params['kwargs'] 2522 # verify the required parameter 'account_id' is set 2523 if ('account_id' not in params) or (params['account_id'] is None): 2524 raise ValueError("Missing the required parameter `account_id` when calling `get_billing_charges`") 2525 2526 2527 collection_formats = {} 2528 2529 resource_path = '/v2.1/accounts/{accountId}/billing_charges'.replace('{format}', 'json') 2530 path_params = {} 2531 if 'account_id' in params: 2532 path_params['accountId'] = params['account_id'] 2533 2534 query_params = {} 2535 if 'include_charges' in params: 2536 query_params['include_charges'] = params['include_charges'] 2537 2538 header_params = {} 2539 2540 form_params = [] 2541 local_var_files = {} 2542 2543 body_params = None 2544 # HTTP header `Accept` 2545 header_params['Accept'] = self.api_client.\ 2546 select_header_accept(['application/json']) 2547 2548 # Authentication setting 2549 auth_settings = [] 2550 2551 return self.api_client.call_api(resource_path, 'GET', 2552 path_params, 2553 query_params, 2554 header_params, 2555 body=body_params, 2556 post_params=form_params, 2557 files=local_var_files, 2558 response_type='BillingChargeResponse', 2559 auth_settings=auth_settings, 2560 callback=params.get('callback'), 2561 _return_http_data_only=params.get('_return_http_data_only'), 2562 _preload_content=params.get('_preload_content', True), 2563 _request_timeout=params.get('_request_timeout'), 2564 collection_formats=collection_formats)
Gets list of recurring and usage charges for the account.
Retrieves the list of recurring and usage charges for the account. This can be used to determine the charge structure and usage of charge plan items. Privileges required: account administrator
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_billing_charges_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include_charges: Specifies which billing charges to return. Valid values are: * envelopes * seats
Returns
BillingChargeResponse If the method is called asynchronously, returns the request thread.
def
get_brand(self, account_id, brand_id, **kwargs)
2566 def get_brand(self, account_id, brand_id, **kwargs): 2567 """ 2568 Get information for a specific brand. 2569 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2570 This method makes a synchronous HTTP request by default. To make an 2571 asynchronous HTTP request, please define a `callback` function 2572 to be invoked when receiving the response. 2573 >>> def callback_function(response): 2574 >>> pprint(response) 2575 >>> 2576 >>> thread = api.get_brand(account_id, brand_id, callback=callback_function) 2577 2578 :param callback function: The callback function 2579 for asynchronous request. (optional) 2580 :param str account_id: The external account number (int) or account ID Guid. (required) 2581 :param str brand_id: The unique identifier of a brand. (required) 2582 :param str include_external_references: 2583 :param str include_logos: 2584 :return: Brand 2585 If the method is called asynchronously, 2586 returns the request thread. 2587 """ 2588 kwargs['_return_http_data_only'] = True 2589 if kwargs.get('callback'): 2590 return self.get_brand_with_http_info(account_id, brand_id, **kwargs) 2591 else: 2592 (data) = self.get_brand_with_http_info(account_id, brand_id, **kwargs) 2593 return data
Get information for a specific brand.
This method returns details about an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str include_external_references:
- str include_logos:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
get_brand_with_http_info(self, account_id, brand_id, **kwargs)
2595 def get_brand_with_http_info(self, account_id, brand_id, **kwargs): 2596 """ 2597 Get information for a specific brand. 2598 This method returns details about an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2599 This method makes a synchronous HTTP request by default. To make an 2600 asynchronous HTTP request, please define a `callback` function 2601 to be invoked when receiving the response. 2602 >>> def callback_function(response): 2603 >>> pprint(response) 2604 >>> 2605 >>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function) 2606 2607 :param callback function: The callback function 2608 for asynchronous request. (optional) 2609 :param str account_id: The external account number (int) or account ID Guid. (required) 2610 :param str brand_id: The unique identifier of a brand. (required) 2611 :param str include_external_references: 2612 :param str include_logos: 2613 :return: Brand 2614 If the method is called asynchronously, 2615 returns the request thread. 2616 """ 2617 2618 all_params = ['account_id', 'brand_id', 'include_external_references', 'include_logos'] 2619 all_params.append('callback') 2620 all_params.append('_return_http_data_only') 2621 all_params.append('_preload_content') 2622 all_params.append('_request_timeout') 2623 2624 params = locals() 2625 for key, val in iteritems(params['kwargs']): 2626 if key not in all_params: 2627 raise TypeError( 2628 "Got an unexpected keyword argument '%s'" 2629 " to method get_brand" % key 2630 ) 2631 params[key] = val 2632 del params['kwargs'] 2633 # verify the required parameter 'account_id' is set 2634 if ('account_id' not in params) or (params['account_id'] is None): 2635 raise ValueError("Missing the required parameter `account_id` when calling `get_brand`") 2636 # verify the required parameter 'brand_id' is set 2637 if ('brand_id' not in params) or (params['brand_id'] is None): 2638 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand`") 2639 2640 2641 collection_formats = {} 2642 2643 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 2644 path_params = {} 2645 if 'account_id' in params: 2646 path_params['accountId'] = params['account_id'] 2647 if 'brand_id' in params: 2648 path_params['brandId'] = params['brand_id'] 2649 2650 query_params = {} 2651 if 'include_external_references' in params: 2652 query_params['include_external_references'] = params['include_external_references'] 2653 if 'include_logos' in params: 2654 query_params['include_logos'] = params['include_logos'] 2655 2656 header_params = {} 2657 2658 form_params = [] 2659 local_var_files = {} 2660 2661 body_params = None 2662 # HTTP header `Accept` 2663 header_params['Accept'] = self.api_client.\ 2664 select_header_accept(['application/json']) 2665 2666 # Authentication setting 2667 auth_settings = [] 2668 2669 return self.api_client.call_api(resource_path, 'GET', 2670 path_params, 2671 query_params, 2672 header_params, 2673 body=body_params, 2674 post_params=form_params, 2675 files=local_var_files, 2676 response_type='Brand', 2677 auth_settings=auth_settings, 2678 callback=params.get('callback'), 2679 _return_http_data_only=params.get('_return_http_data_only'), 2680 _preload_content=params.get('_preload_content', True), 2681 _request_timeout=params.get('_request_timeout'), 2682 collection_formats=collection_formats)
Get information for a specific brand.
This method returns details about an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str include_external_references:
- str include_logos:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
get_brand_export_file(self, account_id, brand_id, **kwargs)
2684 def get_brand_export_file(self, account_id, brand_id, **kwargs): 2685 """ 2686 Export a specific brand. 2687 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2688 This method makes a synchronous HTTP request by default. To make an 2689 asynchronous HTTP request, please define a `callback` function 2690 to be invoked when receiving the response. 2691 >>> def callback_function(response): 2692 >>> pprint(response) 2693 >>> 2694 >>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function) 2695 2696 :param callback function: The callback function 2697 for asynchronous request. (optional) 2698 :param str account_id: The external account number (int) or account ID Guid. (required) 2699 :param str brand_id: The unique identifier of a brand. (required) 2700 :return: None 2701 If the method is called asynchronously, 2702 returns the request thread. 2703 """ 2704 kwargs['_return_http_data_only'] = True 2705 if kwargs.get('callback'): 2706 return self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 2707 else: 2708 (data) = self.get_brand_export_file_with_http_info(account_id, brand_id, **kwargs) 2709 return data
Export a specific brand.
This method exports information about a brand to an XML file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_export_file(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs)
2711 def get_brand_export_file_with_http_info(self, account_id, brand_id, **kwargs): 2712 """ 2713 Export a specific brand. 2714 This method exports information about a brand to an XML file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2715 This method makes a synchronous HTTP request by default. To make an 2716 asynchronous HTTP request, please define a `callback` function 2717 to be invoked when receiving the response. 2718 >>> def callback_function(response): 2719 >>> pprint(response) 2720 >>> 2721 >>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function) 2722 2723 :param callback function: The callback function 2724 for asynchronous request. (optional) 2725 :param str account_id: The external account number (int) or account ID Guid. (required) 2726 :param str brand_id: The unique identifier of a brand. (required) 2727 :return: None 2728 If the method is called asynchronously, 2729 returns the request thread. 2730 """ 2731 2732 all_params = ['account_id', 'brand_id'] 2733 all_params.append('callback') 2734 all_params.append('_return_http_data_only') 2735 all_params.append('_preload_content') 2736 all_params.append('_request_timeout') 2737 2738 params = locals() 2739 for key, val in iteritems(params['kwargs']): 2740 if key not in all_params: 2741 raise TypeError( 2742 "Got an unexpected keyword argument '%s'" 2743 " to method get_brand_export_file" % key 2744 ) 2745 params[key] = val 2746 del params['kwargs'] 2747 # verify the required parameter 'account_id' is set 2748 if ('account_id' not in params) or (params['account_id'] is None): 2749 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_export_file`") 2750 # verify the required parameter 'brand_id' is set 2751 if ('brand_id' not in params) or (params['brand_id'] is None): 2752 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_export_file`") 2753 2754 2755 collection_formats = {} 2756 2757 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/file'.replace('{format}', 'json') 2758 path_params = {} 2759 if 'account_id' in params: 2760 path_params['accountId'] = params['account_id'] 2761 if 'brand_id' in params: 2762 path_params['brandId'] = params['brand_id'] 2763 2764 query_params = {} 2765 2766 header_params = {} 2767 2768 form_params = [] 2769 local_var_files = {} 2770 2771 body_params = None 2772 # HTTP header `Accept` 2773 header_params['Accept'] = self.api_client.\ 2774 select_header_accept(['application/json']) 2775 2776 # Authentication setting 2777 auth_settings = [] 2778 2779 return self.api_client.call_api(resource_path, 'GET', 2780 path_params, 2781 query_params, 2782 header_params, 2783 body=body_params, 2784 post_params=form_params, 2785 files=local_var_files, 2786 response_type=None, 2787 auth_settings=auth_settings, 2788 callback=params.get('callback'), 2789 _return_http_data_only=params.get('_return_http_data_only'), 2790 _preload_content=params.get('_preload_content', True), 2791 _request_timeout=params.get('_request_timeout'), 2792 collection_formats=collection_formats)
Export a specific brand.
This method exports information about a brand to an XML file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_export_file_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs)
2794 def get_brand_logo_by_type(self, account_id, brand_id, logo_type, **kwargs): 2795 """ 2796 Obtains the specified image for a brand. 2797 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2798 This method makes a synchronous HTTP request by default. To make an 2799 asynchronous HTTP request, please define a `callback` function 2800 to be invoked when receiving the response. 2801 >>> def callback_function(response): 2802 >>> pprint(response) 2803 >>> 2804 >>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function) 2805 2806 :param callback function: The callback function 2807 for asynchronous request. (optional) 2808 :param str account_id: The external account number (int) or account ID Guid. (required) 2809 :param str brand_id: The unique identifier of a brand. (required) 2810 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 2811 :return: file 2812 If the method is called asynchronously, 2813 returns the request thread. 2814 """ 2815 kwargs['_return_http_data_only'] = True 2816 if kwargs.get('callback'): 2817 return self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 2818 else: 2819 (data) = self.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, **kwargs) 2820 return data
Obtains the specified image for a brand.
This method returns a specific logo that is used in a brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_logo_by_type(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
file If the method is called asynchronously, returns the request thread.
def
get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs)
2822 def get_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, **kwargs): 2823 """ 2824 Obtains the specified image for a brand. 2825 This method returns a specific logo that is used in a brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2826 This method makes a synchronous HTTP request by default. To make an 2827 asynchronous HTTP request, please define a `callback` function 2828 to be invoked when receiving the response. 2829 >>> def callback_function(response): 2830 >>> pprint(response) 2831 >>> 2832 >>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function) 2833 2834 :param callback function: The callback function 2835 for asynchronous request. (optional) 2836 :param str account_id: The external account number (int) or account ID Guid. (required) 2837 :param str brand_id: The unique identifier of a brand. (required) 2838 :param str logo_type: One of **Primary**, **Secondary** or **Email**. (required) 2839 :return: file 2840 If the method is called asynchronously, 2841 returns the request thread. 2842 """ 2843 2844 all_params = ['account_id', 'brand_id', 'logo_type'] 2845 all_params.append('callback') 2846 all_params.append('_return_http_data_only') 2847 all_params.append('_preload_content') 2848 all_params.append('_request_timeout') 2849 2850 params = locals() 2851 for key, val in iteritems(params['kwargs']): 2852 if key not in all_params: 2853 raise TypeError( 2854 "Got an unexpected keyword argument '%s'" 2855 " to method get_brand_logo_by_type" % key 2856 ) 2857 params[key] = val 2858 del params['kwargs'] 2859 # verify the required parameter 'account_id' is set 2860 if ('account_id' not in params) or (params['account_id'] is None): 2861 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_logo_by_type`") 2862 # verify the required parameter 'brand_id' is set 2863 if ('brand_id' not in params) or (params['brand_id'] is None): 2864 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_logo_by_type`") 2865 # verify the required parameter 'logo_type' is set 2866 if ('logo_type' not in params) or (params['logo_type'] is None): 2867 raise ValueError("Missing the required parameter `logo_type` when calling `get_brand_logo_by_type`") 2868 2869 2870 collection_formats = {} 2871 2872 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 2873 path_params = {} 2874 if 'account_id' in params: 2875 path_params['accountId'] = params['account_id'] 2876 if 'brand_id' in params: 2877 path_params['brandId'] = params['brand_id'] 2878 if 'logo_type' in params: 2879 path_params['logoType'] = params['logo_type'] 2880 2881 query_params = {} 2882 2883 header_params = {} 2884 2885 form_params = [] 2886 local_var_files = {} 2887 2888 body_params = None 2889 # HTTP header `Accept` 2890 header_params['Accept'] = self.api_client.\ 2891 select_header_accept(['image/png']) 2892 2893 # Authentication setting 2894 auth_settings = [] 2895 2896 return self.api_client.call_api(resource_path, 'GET', 2897 path_params, 2898 query_params, 2899 header_params, 2900 body=body_params, 2901 post_params=form_params, 2902 files=local_var_files, 2903 response_type='file', 2904 auth_settings=auth_settings, 2905 callback=params.get('callback'), 2906 _return_http_data_only=params.get('_return_http_data_only'), 2907 _preload_content=params.get('_preload_content', True), 2908 _request_timeout=params.get('_request_timeout'), 2909 collection_formats=collection_formats)
Obtains the specified image for a brand.
This method returns a specific logo that is used in a brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str logo_type: One of Primary, Secondary or Email. (required)
Returns
file If the method is called asynchronously, returns the request thread.
def
get_brand_resources(self, account_id, brand_id, **kwargs)
2911 def get_brand_resources(self, account_id, brand_id, **kwargs): 2912 """ 2913 Returns the specified account's list of branding resources (metadata). 2914 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2915 This method makes a synchronous HTTP request by default. To make an 2916 asynchronous HTTP request, please define a `callback` function 2917 to be invoked when receiving the response. 2918 >>> def callback_function(response): 2919 >>> pprint(response) 2920 >>> 2921 >>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function) 2922 2923 :param callback function: The callback function 2924 for asynchronous request. (optional) 2925 :param str account_id: The external account number (int) or account ID Guid. (required) 2926 :param str brand_id: The unique identifier of a brand. (required) 2927 :return: BrandResourcesList 2928 If the method is called asynchronously, 2929 returns the request thread. 2930 """ 2931 kwargs['_return_http_data_only'] = True 2932 if kwargs.get('callback'): 2933 return self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 2934 else: 2935 (data) = self.get_brand_resources_with_http_info(account_id, brand_id, **kwargs) 2936 return data
Returns the specified account's list of branding resources (metadata).
This method returns metadata about the branding resources that are associated with an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_resources(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
BrandResourcesList If the method is called asynchronously, returns the request thread.
def
get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs)
2938 def get_brand_resources_with_http_info(self, account_id, brand_id, **kwargs): 2939 """ 2940 Returns the specified account's list of branding resources (metadata). 2941 This method returns metadata about the branding resources that are associated with an account. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 2942 This method makes a synchronous HTTP request by default. To make an 2943 asynchronous HTTP request, please define a `callback` function 2944 to be invoked when receiving the response. 2945 >>> def callback_function(response): 2946 >>> pprint(response) 2947 >>> 2948 >>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function) 2949 2950 :param callback function: The callback function 2951 for asynchronous request. (optional) 2952 :param str account_id: The external account number (int) or account ID Guid. (required) 2953 :param str brand_id: The unique identifier of a brand. (required) 2954 :return: BrandResourcesList 2955 If the method is called asynchronously, 2956 returns the request thread. 2957 """ 2958 2959 all_params = ['account_id', 'brand_id'] 2960 all_params.append('callback') 2961 all_params.append('_return_http_data_only') 2962 all_params.append('_preload_content') 2963 all_params.append('_request_timeout') 2964 2965 params = locals() 2966 for key, val in iteritems(params['kwargs']): 2967 if key not in all_params: 2968 raise TypeError( 2969 "Got an unexpected keyword argument '%s'" 2970 " to method get_brand_resources" % key 2971 ) 2972 params[key] = val 2973 del params['kwargs'] 2974 # verify the required parameter 'account_id' is set 2975 if ('account_id' not in params) or (params['account_id'] is None): 2976 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources`") 2977 # verify the required parameter 'brand_id' is set 2978 if ('brand_id' not in params) or (params['brand_id'] is None): 2979 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources`") 2980 2981 2982 collection_formats = {} 2983 2984 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources'.replace('{format}', 'json') 2985 path_params = {} 2986 if 'account_id' in params: 2987 path_params['accountId'] = params['account_id'] 2988 if 'brand_id' in params: 2989 path_params['brandId'] = params['brand_id'] 2990 2991 query_params = {} 2992 2993 header_params = {} 2994 2995 form_params = [] 2996 local_var_files = {} 2997 2998 body_params = None 2999 # HTTP header `Accept` 3000 header_params['Accept'] = self.api_client.\ 3001 select_header_accept(['application/json']) 3002 3003 # Authentication setting 3004 auth_settings = [] 3005 3006 return self.api_client.call_api(resource_path, 'GET', 3007 path_params, 3008 query_params, 3009 header_params, 3010 body=body_params, 3011 post_params=form_params, 3012 files=local_var_files, 3013 response_type='BrandResourcesList', 3014 auth_settings=auth_settings, 3015 callback=params.get('callback'), 3016 _return_http_data_only=params.get('_return_http_data_only'), 3017 _preload_content=params.get('_preload_content', True), 3018 _request_timeout=params.get('_request_timeout'), 3019 collection_formats=collection_formats)
Returns the specified account's list of branding resources (metadata).
This method returns metadata about the branding resources that are associated with an account. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_resources_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
Returns
BrandResourcesList If the method is called asynchronously, returns the request thread.
def
get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs)
3021 def get_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, **kwargs): 3022 """ 3023 Returns the specified branding resource file. 3024 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3025 This method makes a synchronous HTTP request by default. To make an 3026 asynchronous HTTP request, please define a `callback` function 3027 to be invoked when receiving the response. 3028 >>> def callback_function(response): 3029 >>> pprint(response) 3030 >>> 3031 >>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function) 3032 3033 :param callback function: The callback function 3034 for asynchronous request. (optional) 3035 :param str account_id: The external account number (int) or account ID Guid. (required) 3036 :param str brand_id: The unique identifier of a brand. (required) 3037 :param str resource_content_type: (required) 3038 :param str langcode: 3039 :param str return_master: 3040 :return: None 3041 If the method is called asynchronously, 3042 returns the request thread. 3043 """ 3044 kwargs['_return_http_data_only'] = True 3045 if kwargs.get('callback'): 3046 return self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3047 else: 3048 (data) = self.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, **kwargs) 3049 return data
Returns the specified branding resource file.
This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. Important: When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_resources_by_content_type(account_id, brand_id, resource_content_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str resource_content_type: (required)
- str langcode:
- str return_master:
Returns
None If the method is called asynchronously, returns the request thread.
def
get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs)
3051 def get_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, **kwargs): 3052 """ 3053 Returns the specified branding resource file. 3054 This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. **Important:** When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 3055 This method makes a synchronous HTTP request by default. To make an 3056 asynchronous HTTP request, please define a `callback` function 3057 to be invoked when receiving the response. 3058 >>> def callback_function(response): 3059 >>> pprint(response) 3060 >>> 3061 >>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function) 3062 3063 :param callback function: The callback function 3064 for asynchronous request. (optional) 3065 :param str account_id: The external account number (int) or account ID Guid. (required) 3066 :param str brand_id: The unique identifier of a brand. (required) 3067 :param str resource_content_type: (required) 3068 :param str langcode: 3069 :param str return_master: 3070 :return: None 3071 If the method is called asynchronously, 3072 returns the request thread. 3073 """ 3074 3075 all_params = ['account_id', 'brand_id', 'resource_content_type', 'langcode', 'return_master'] 3076 all_params.append('callback') 3077 all_params.append('_return_http_data_only') 3078 all_params.append('_preload_content') 3079 all_params.append('_request_timeout') 3080 3081 params = locals() 3082 for key, val in iteritems(params['kwargs']): 3083 if key not in all_params: 3084 raise TypeError( 3085 "Got an unexpected keyword argument '%s'" 3086 " to method get_brand_resources_by_content_type" % key 3087 ) 3088 params[key] = val 3089 del params['kwargs'] 3090 # verify the required parameter 'account_id' is set 3091 if ('account_id' not in params) or (params['account_id'] is None): 3092 raise ValueError("Missing the required parameter `account_id` when calling `get_brand_resources_by_content_type`") 3093 # verify the required parameter 'brand_id' is set 3094 if ('brand_id' not in params) or (params['brand_id'] is None): 3095 raise ValueError("Missing the required parameter `brand_id` when calling `get_brand_resources_by_content_type`") 3096 # verify the required parameter 'resource_content_type' is set 3097 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 3098 raise ValueError("Missing the required parameter `resource_content_type` when calling `get_brand_resources_by_content_type`") 3099 3100 3101 collection_formats = {} 3102 3103 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 3104 path_params = {} 3105 if 'account_id' in params: 3106 path_params['accountId'] = params['account_id'] 3107 if 'brand_id' in params: 3108 path_params['brandId'] = params['brand_id'] 3109 if 'resource_content_type' in params: 3110 path_params['resourceContentType'] = params['resource_content_type'] 3111 3112 query_params = {} 3113 if 'langcode' in params: 3114 query_params['langcode'] = params['langcode'] 3115 if 'return_master' in params: 3116 query_params['return_master'] = params['return_master'] 3117 3118 header_params = {} 3119 3120 form_params = [] 3121 local_var_files = {} 3122 3123 body_params = None 3124 # HTTP header `Accept` 3125 header_params['Accept'] = self.api_client.\ 3126 select_header_accept(['application/json']) 3127 3128 # Authentication setting 3129 auth_settings = [] 3130 3131 return self.api_client.call_api(resource_path, 'GET', 3132 path_params, 3133 query_params, 3134 header_params, 3135 body=body_params, 3136 post_params=form_params, 3137 files=local_var_files, 3138 response_type=None, 3139 auth_settings=auth_settings, 3140 callback=params.get('callback'), 3141 _return_http_data_only=params.get('_return_http_data_only'), 3142 _preload_content=params.get('_preload_content', True), 3143 _request_timeout=params.get('_request_timeout'), 3144 collection_formats=collection_formats)
Returns the specified branding resource file.
This method returns a specific branding resource file. A brand uses a set of brand resource files to control the sending, signing, email message, and captive (embedded) signing experiences. You can modify the default email messages and formats in these files and upload them to your brand to customize the user experience. Important: When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str resource_content_type: (required)
- str langcode:
- str return_master:
Returns
None If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure(self, account_id, lang_code, **kwargs)
3146 def get_consumer_disclosure(self, account_id, lang_code, **kwargs): 3147 """ 3148 Gets the Electronic Record and Signature Disclosure. 3149 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3150 This method makes a synchronous HTTP request by default. To make an 3151 asynchronous HTTP request, please define a `callback` function 3152 to be invoked when receiving the response. 3153 >>> def callback_function(response): 3154 >>> pprint(response) 3155 >>> 3156 >>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function) 3157 3158 :param callback function: The callback function 3159 for asynchronous request. (optional) 3160 :param str account_id: The external account number (int) or account ID Guid. (required) 3161 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3162 :return: ConsumerDisclosure 3163 If the method is called asynchronously, 3164 returns the request thread. 3165 """ 3166 kwargs['_return_http_data_only'] = True 3167 if kwargs.get('callback'): 3168 return self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3169 else: 3170 (data) = self.get_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 3171 return data
Gets the Electronic Record and Signature Disclosure.
Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs)
3173 def get_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 3174 """ 3175 Gets the Electronic Record and Signature Disclosure. 3176 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure. 3177 This method makes a synchronous HTTP request by default. To make an 3178 asynchronous HTTP request, please define a `callback` function 3179 to be invoked when receiving the response. 3180 >>> def callback_function(response): 3181 >>> pprint(response) 3182 >>> 3183 >>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 3184 3185 :param callback function: The callback function 3186 for asynchronous request. (optional) 3187 :param str account_id: The external account number (int) or account ID Guid. (required) 3188 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 3189 :return: ConsumerDisclosure 3190 If the method is called asynchronously, 3191 returns the request thread. 3192 """ 3193 3194 all_params = ['account_id', 'lang_code'] 3195 all_params.append('callback') 3196 all_params.append('_return_http_data_only') 3197 all_params.append('_preload_content') 3198 all_params.append('_request_timeout') 3199 3200 params = locals() 3201 for key, val in iteritems(params['kwargs']): 3202 if key not in all_params: 3203 raise TypeError( 3204 "Got an unexpected keyword argument '%s'" 3205 " to method get_consumer_disclosure" % key 3206 ) 3207 params[key] = val 3208 del params['kwargs'] 3209 # verify the required parameter 'account_id' is set 3210 if ('account_id' not in params) or (params['account_id'] is None): 3211 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure`") 3212 # verify the required parameter 'lang_code' is set 3213 if ('lang_code' not in params) or (params['lang_code'] is None): 3214 raise ValueError("Missing the required parameter `lang_code` when calling `get_consumer_disclosure`") 3215 3216 3217 collection_formats = {} 3218 3219 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 3220 path_params = {} 3221 if 'account_id' in params: 3222 path_params['accountId'] = params['account_id'] 3223 if 'lang_code' in params: 3224 path_params['langCode'] = params['lang_code'] 3225 3226 query_params = {} 3227 3228 header_params = {} 3229 3230 form_params = [] 3231 local_var_files = {} 3232 3233 body_params = None 3234 # HTTP header `Accept` 3235 header_params['Accept'] = self.api_client.\ 3236 select_header_accept(['application/json']) 3237 3238 # Authentication setting 3239 auth_settings = [] 3240 3241 return self.api_client.call_api(resource_path, 'GET', 3242 path_params, 3243 query_params, 3244 header_params, 3245 body=body_params, 3246 post_params=form_params, 3247 files=local_var_files, 3248 response_type='ConsumerDisclosure', 3249 auth_settings=auth_settings, 3250 callback=params.get('callback'), 3251 _return_http_data_only=params.get('_return_http_data_only'), 3252 _preload_content=params.get('_preload_content', True), 3253 _request_timeout=params.get('_request_timeout'), 3254 collection_formats=collection_formats)
Gets the Electronic Record and Signature Disclosure.
Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, for the requested envelope recipient. This might be different than the current account disclosure depending on account settings, such as branding, and when the account disclosure was last updated. An optional query string can be included to return the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_default(self, account_id, **kwargs)
3256 def get_consumer_disclosure_default(self, account_id, **kwargs): 3257 """ 3258 Gets the Electronic Record and Signature Disclosure for the account. 3259 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 3260 This method makes a synchronous HTTP request by default. To make an 3261 asynchronous HTTP request, please define a `callback` function 3262 to be invoked when receiving the response. 3263 >>> def callback_function(response): 3264 >>> pprint(response) 3265 >>> 3266 >>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function) 3267 3268 :param callback function: The callback function 3269 for asynchronous request. (optional) 3270 :param str account_id: The external account number (int) or account ID Guid. (required) 3271 :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 3272 :return: ConsumerDisclosure 3273 If the method is called asynchronously, 3274 returns the request thread. 3275 """ 3276 kwargs['_return_http_data_only'] = True 3277 if kwargs.get('callback'): 3278 return self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3279 else: 3280 (data) = self.get_consumer_disclosure_default_with_http_info(account_id, **kwargs) 3281 return data
Gets the Electronic Record and Signature Disclosure for the account.
Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_default(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to
browserto automatically detect the browser language being used by the viewer and display the disclosure in that language.
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs)
3283 def get_consumer_disclosure_default_with_http_info(self, account_id, **kwargs): 3284 """ 3285 Gets the Electronic Record and Signature Disclosure for the account. 3286 Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure. 3287 This method makes a synchronous HTTP request by default. To make an 3288 asynchronous HTTP request, please define a `callback` function 3289 to be invoked when receiving the response. 3290 >>> def callback_function(response): 3291 >>> pprint(response) 3292 >>> 3293 >>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function) 3294 3295 :param callback function: The callback function 3296 for asynchronous request. (optional) 3297 :param str account_id: The external account number (int) or account ID Guid. (required) 3298 :param str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to `browser` to automatically detect the browser language being used by the viewer and display the disclosure in that language. 3299 :return: ConsumerDisclosure 3300 If the method is called asynchronously, 3301 returns the request thread. 3302 """ 3303 3304 all_params = ['account_id', 'lang_code'] 3305 all_params.append('callback') 3306 all_params.append('_return_http_data_only') 3307 all_params.append('_preload_content') 3308 all_params.append('_request_timeout') 3309 3310 params = locals() 3311 for key, val in iteritems(params['kwargs']): 3312 if key not in all_params: 3313 raise TypeError( 3314 "Got an unexpected keyword argument '%s'" 3315 " to method get_consumer_disclosure_default" % key 3316 ) 3317 params[key] = val 3318 del params['kwargs'] 3319 # verify the required parameter 'account_id' is set 3320 if ('account_id' not in params) or (params['account_id'] is None): 3321 raise ValueError("Missing the required parameter `account_id` when calling `get_consumer_disclosure_default`") 3322 3323 3324 collection_formats = {} 3325 3326 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure'.replace('{format}', 'json') 3327 path_params = {} 3328 if 'account_id' in params: 3329 path_params['accountId'] = params['account_id'] 3330 3331 query_params = {} 3332 if 'lang_code' in params: 3333 query_params['langCode'] = params['lang_code'] 3334 3335 header_params = {} 3336 3337 form_params = [] 3338 local_var_files = {} 3339 3340 body_params = None 3341 # HTTP header `Accept` 3342 header_params['Accept'] = self.api_client.\ 3343 select_header_accept(['application/json']) 3344 3345 # Authentication setting 3346 auth_settings = [] 3347 3348 return self.api_client.call_api(resource_path, 'GET', 3349 path_params, 3350 query_params, 3351 header_params, 3352 body=body_params, 3353 post_params=form_params, 3354 files=local_var_files, 3355 response_type='ConsumerDisclosure', 3356 auth_settings=auth_settings, 3357 callback=params.get('callback'), 3358 _return_http_data_only=params.get('_return_http_data_only'), 3359 _preload_content=params.get('_preload_content', True), 3360 _request_timeout=params.get('_request_timeout'), 3361 collection_formats=collection_formats)
Gets the Electronic Record and Signature Disclosure for the account.
Retrieves the Electronic Record and Signature Disclosure, with HTML formatting, associated with the account. You can use an optional query string to set the language for the disclosure.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_consumer_disclosure_default_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: Specifies the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk), and Vietnamese (vi). Additionally, the value can be set to
browserto automatically detect the browser language being used by the viewer and display the disclosure in that language.
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
get_e_note_configuration(self, account_id, **kwargs)
3363 def get_e_note_configuration(self, account_id, **kwargs): 3364 """ 3365 Returns the configuration information for the eNote eOriginal integration. 3366 3367 This method makes a synchronous HTTP request by default. To make an 3368 asynchronous HTTP request, please define a `callback` function 3369 to be invoked when receiving the response. 3370 >>> def callback_function(response): 3371 >>> pprint(response) 3372 >>> 3373 >>> thread = api.get_e_note_configuration(account_id, callback=callback_function) 3374 3375 :param callback function: The callback function 3376 for asynchronous request. (optional) 3377 :param str account_id: The external account number (int) or account ID Guid. (required) 3378 :return: ENoteConfiguration 3379 If the method is called asynchronously, 3380 returns the request thread. 3381 """ 3382 kwargs['_return_http_data_only'] = True 3383 if kwargs.get('callback'): 3384 return self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3385 else: 3386 (data) = self.get_e_note_configuration_with_http_info(account_id, **kwargs) 3387 return data
Returns the configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_e_note_configuration(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
get_e_note_configuration_with_http_info(self, account_id, **kwargs)
3389 def get_e_note_configuration_with_http_info(self, account_id, **kwargs): 3390 """ 3391 Returns the configuration information for the eNote eOriginal integration. 3392 3393 This method makes a synchronous HTTP request by default. To make an 3394 asynchronous HTTP request, please define a `callback` function 3395 to be invoked when receiving the response. 3396 >>> def callback_function(response): 3397 >>> pprint(response) 3398 >>> 3399 >>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function) 3400 3401 :param callback function: The callback function 3402 for asynchronous request. (optional) 3403 :param str account_id: The external account number (int) or account ID Guid. (required) 3404 :return: ENoteConfiguration 3405 If the method is called asynchronously, 3406 returns the request thread. 3407 """ 3408 3409 all_params = ['account_id'] 3410 all_params.append('callback') 3411 all_params.append('_return_http_data_only') 3412 all_params.append('_preload_content') 3413 all_params.append('_request_timeout') 3414 3415 params = locals() 3416 for key, val in iteritems(params['kwargs']): 3417 if key not in all_params: 3418 raise TypeError( 3419 "Got an unexpected keyword argument '%s'" 3420 " to method get_e_note_configuration" % key 3421 ) 3422 params[key] = val 3423 del params['kwargs'] 3424 # verify the required parameter 'account_id' is set 3425 if ('account_id' not in params) or (params['account_id'] is None): 3426 raise ValueError("Missing the required parameter `account_id` when calling `get_e_note_configuration`") 3427 3428 3429 collection_formats = {} 3430 3431 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 3432 path_params = {} 3433 if 'account_id' in params: 3434 path_params['accountId'] = params['account_id'] 3435 3436 query_params = {} 3437 3438 header_params = {} 3439 3440 form_params = [] 3441 local_var_files = {} 3442 3443 body_params = None 3444 # HTTP header `Accept` 3445 header_params['Accept'] = self.api_client.\ 3446 select_header_accept(['application/json']) 3447 3448 # Authentication setting 3449 auth_settings = [] 3450 3451 return self.api_client.call_api(resource_path, 'GET', 3452 path_params, 3453 query_params, 3454 header_params, 3455 body=body_params, 3456 post_params=form_params, 3457 files=local_var_files, 3458 response_type='ENoteConfiguration', 3459 auth_settings=auth_settings, 3460 callback=params.get('callback'), 3461 _return_http_data_only=params.get('_return_http_data_only'), 3462 _preload_content=params.get('_preload_content', True), 3463 _request_timeout=params.get('_request_timeout'), 3464 collection_formats=collection_formats)
Returns the configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_e_note_configuration_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
get_envelope_purge_configuration(self, account_id, **kwargs)
3466 def get_envelope_purge_configuration(self, account_id, **kwargs): 3467 """ 3468 Select envelope purge configuration. 3469 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 3470 This method makes a synchronous HTTP request by default. To make an 3471 asynchronous HTTP request, please define a `callback` function 3472 to be invoked when receiving the response. 3473 >>> def callback_function(response): 3474 >>> pprint(response) 3475 >>> 3476 >>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function) 3477 3478 :param callback function: The callback function 3479 for asynchronous request. (optional) 3480 :param str account_id: The external account number (int) or account ID Guid. (required) 3481 :return: EnvelopePurgeConfiguration 3482 If the method is called asynchronously, 3483 returns the request thread. 3484 """ 3485 kwargs['_return_http_data_only'] = True 3486 if kwargs.get('callback'): 3487 return self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 3488 else: 3489 (data) = self.get_envelope_purge_configuration_with_http_info(account_id, **kwargs) 3490 return data
Select envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method retrieves the current envelope purge configuration for your account. Note: To use this method, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_purge_configuration(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs)
3492 def get_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 3493 """ 3494 Select envelope purge configuration. 3495 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method retrieves the current envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. 3496 This method makes a synchronous HTTP request by default. To make an 3497 asynchronous HTTP request, please define a `callback` function 3498 to be invoked when receiving the response. 3499 >>> def callback_function(response): 3500 >>> pprint(response) 3501 >>> 3502 >>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 3503 3504 :param callback function: The callback function 3505 for asynchronous request. (optional) 3506 :param str account_id: The external account number (int) or account ID Guid. (required) 3507 :return: EnvelopePurgeConfiguration 3508 If the method is called asynchronously, 3509 returns the request thread. 3510 """ 3511 3512 all_params = ['account_id'] 3513 all_params.append('callback') 3514 all_params.append('_return_http_data_only') 3515 all_params.append('_preload_content') 3516 all_params.append('_request_timeout') 3517 3518 params = locals() 3519 for key, val in iteritems(params['kwargs']): 3520 if key not in all_params: 3521 raise TypeError( 3522 "Got an unexpected keyword argument '%s'" 3523 " to method get_envelope_purge_configuration" % key 3524 ) 3525 params[key] = val 3526 del params['kwargs'] 3527 # verify the required parameter 'account_id' is set 3528 if ('account_id' not in params) or (params['account_id'] is None): 3529 raise ValueError("Missing the required parameter `account_id` when calling `get_envelope_purge_configuration`") 3530 3531 3532 collection_formats = {} 3533 3534 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 3535 path_params = {} 3536 if 'account_id' in params: 3537 path_params['accountId'] = params['account_id'] 3538 3539 query_params = {} 3540 3541 header_params = {} 3542 3543 form_params = [] 3544 local_var_files = {} 3545 3546 body_params = None 3547 # HTTP header `Accept` 3548 header_params['Accept'] = self.api_client.\ 3549 select_header_accept(['application/json']) 3550 3551 # Authentication setting 3552 auth_settings = [] 3553 3554 return self.api_client.call_api(resource_path, 'GET', 3555 path_params, 3556 query_params, 3557 header_params, 3558 body=body_params, 3559 post_params=form_params, 3560 files=local_var_files, 3561 response_type='EnvelopePurgeConfiguration', 3562 auth_settings=auth_settings, 3563 callback=params.get('callback'), 3564 _return_http_data_only=params.get('_return_http_data_only'), 3565 _preload_content=params.get('_preload_content', True), 3566 _request_timeout=params.get('_request_timeout'), 3567 collection_formats=collection_formats)
Select envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method retrieves the current envelope purge configuration for your account. Note: To use this method, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
get_favorite_templates(self, account_id, **kwargs)
3569 def get_favorite_templates(self, account_id, **kwargs): 3570 """ 3571 Retrieves the list of favorited templates for this caller 3572 3573 This method makes a synchronous HTTP request by default. To make an 3574 asynchronous HTTP request, please define a `callback` function 3575 to be invoked when receiving the response. 3576 >>> def callback_function(response): 3577 >>> pprint(response) 3578 >>> 3579 >>> thread = api.get_favorite_templates(account_id, callback=callback_function) 3580 3581 :param callback function: The callback function 3582 for asynchronous request. (optional) 3583 :param str account_id: The external account number (int) or account ID Guid. (required) 3584 :return: FavoriteTemplatesInfo 3585 If the method is called asynchronously, 3586 returns the request thread. 3587 """ 3588 kwargs['_return_http_data_only'] = True 3589 if kwargs.get('callback'): 3590 return self.get_favorite_templates_with_http_info(account_id, **kwargs) 3591 else: 3592 (data) = self.get_favorite_templates_with_http_info(account_id, **kwargs) 3593 return data
Retrieves the list of favorited templates for this caller
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_favorite_templates(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
get_favorite_templates_with_http_info(self, account_id, **kwargs)
3595 def get_favorite_templates_with_http_info(self, account_id, **kwargs): 3596 """ 3597 Retrieves the list of favorited templates for this caller 3598 3599 This method makes a synchronous HTTP request by default. To make an 3600 asynchronous HTTP request, please define a `callback` function 3601 to be invoked when receiving the response. 3602 >>> def callback_function(response): 3603 >>> pprint(response) 3604 >>> 3605 >>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function) 3606 3607 :param callback function: The callback function 3608 for asynchronous request. (optional) 3609 :param str account_id: The external account number (int) or account ID Guid. (required) 3610 :return: FavoriteTemplatesInfo 3611 If the method is called asynchronously, 3612 returns the request thread. 3613 """ 3614 3615 all_params = ['account_id'] 3616 all_params.append('callback') 3617 all_params.append('_return_http_data_only') 3618 all_params.append('_preload_content') 3619 all_params.append('_request_timeout') 3620 3621 params = locals() 3622 for key, val in iteritems(params['kwargs']): 3623 if key not in all_params: 3624 raise TypeError( 3625 "Got an unexpected keyword argument '%s'" 3626 " to method get_favorite_templates" % key 3627 ) 3628 params[key] = val 3629 del params['kwargs'] 3630 # verify the required parameter 'account_id' is set 3631 if ('account_id' not in params) or (params['account_id'] is None): 3632 raise ValueError("Missing the required parameter `account_id` when calling `get_favorite_templates`") 3633 3634 3635 collection_formats = {} 3636 3637 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 3638 path_params = {} 3639 if 'account_id' in params: 3640 path_params['accountId'] = params['account_id'] 3641 3642 query_params = {} 3643 3644 header_params = {} 3645 3646 form_params = [] 3647 local_var_files = {} 3648 3649 body_params = None 3650 # HTTP header `Accept` 3651 header_params['Accept'] = self.api_client.\ 3652 select_header_accept(['application/json']) 3653 3654 # Authentication setting 3655 auth_settings = [] 3656 3657 return self.api_client.call_api(resource_path, 'GET', 3658 path_params, 3659 query_params, 3660 header_params, 3661 body=body_params, 3662 post_params=form_params, 3663 files=local_var_files, 3664 response_type='FavoriteTemplatesInfo', 3665 auth_settings=auth_settings, 3666 callback=params.get('callback'), 3667 _return_http_data_only=params.get('_return_http_data_only'), 3668 _preload_content=params.get('_preload_content', True), 3669 _request_timeout=params.get('_request_timeout'), 3670 collection_formats=collection_formats)
Retrieves the list of favorited templates for this caller
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_favorite_templates_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
get_notification_defaults(self, account_id, **kwargs)
3672 def get_notification_defaults(self, account_id, **kwargs): 3673 """ 3674 Returns default user level settings for a specified account 3675 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 3676 This method makes a synchronous HTTP request by default. To make an 3677 asynchronous HTTP request, please define a `callback` function 3678 to be invoked when receiving the response. 3679 >>> def callback_function(response): 3680 >>> pprint(response) 3681 >>> 3682 >>> thread = api.get_notification_defaults(account_id, callback=callback_function) 3683 3684 :param callback function: The callback function 3685 for asynchronous request. (optional) 3686 :param str account_id: The external account number (int) or account ID Guid. (required) 3687 :return: NotificationDefaults 3688 If the method is called asynchronously, 3689 returns the request thread. 3690 """ 3691 kwargs['_return_http_data_only'] = True 3692 if kwargs.get('callback'): 3693 return self.get_notification_defaults_with_http_info(account_id, **kwargs) 3694 else: 3695 (data) = self.get_notification_defaults_with_http_info(account_id, **kwargs) 3696 return data
Returns default user level settings for a specified account
This method returns the default settings for the email notifications that signers and senders receive about envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_notification_defaults(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
get_notification_defaults_with_http_info(self, account_id, **kwargs)
3698 def get_notification_defaults_with_http_info(self, account_id, **kwargs): 3699 """ 3700 Returns default user level settings for a specified account 3701 This method returns the default settings for the email notifications that signers and senders receive about envelopes. 3702 This method makes a synchronous HTTP request by default. To make an 3703 asynchronous HTTP request, please define a `callback` function 3704 to be invoked when receiving the response. 3705 >>> def callback_function(response): 3706 >>> pprint(response) 3707 >>> 3708 >>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function) 3709 3710 :param callback function: The callback function 3711 for asynchronous request. (optional) 3712 :param str account_id: The external account number (int) or account ID Guid. (required) 3713 :return: NotificationDefaults 3714 If the method is called asynchronously, 3715 returns the request thread. 3716 """ 3717 3718 all_params = ['account_id'] 3719 all_params.append('callback') 3720 all_params.append('_return_http_data_only') 3721 all_params.append('_preload_content') 3722 all_params.append('_request_timeout') 3723 3724 params = locals() 3725 for key, val in iteritems(params['kwargs']): 3726 if key not in all_params: 3727 raise TypeError( 3728 "Got an unexpected keyword argument '%s'" 3729 " to method get_notification_defaults" % key 3730 ) 3731 params[key] = val 3732 del params['kwargs'] 3733 # verify the required parameter 'account_id' is set 3734 if ('account_id' not in params) or (params['account_id'] is None): 3735 raise ValueError("Missing the required parameter `account_id` when calling `get_notification_defaults`") 3736 3737 3738 collection_formats = {} 3739 3740 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 3741 path_params = {} 3742 if 'account_id' in params: 3743 path_params['accountId'] = params['account_id'] 3744 3745 query_params = {} 3746 3747 header_params = {} 3748 3749 form_params = [] 3750 local_var_files = {} 3751 3752 body_params = None 3753 # HTTP header `Accept` 3754 header_params['Accept'] = self.api_client.\ 3755 select_header_accept(['application/json']) 3756 3757 # Authentication setting 3758 auth_settings = [] 3759 3760 return self.api_client.call_api(resource_path, 'GET', 3761 path_params, 3762 query_params, 3763 header_params, 3764 body=body_params, 3765 post_params=form_params, 3766 files=local_var_files, 3767 response_type='NotificationDefaults', 3768 auth_settings=auth_settings, 3769 callback=params.get('callback'), 3770 _return_http_data_only=params.get('_return_http_data_only'), 3771 _preload_content=params.get('_preload_content', True), 3772 _request_timeout=params.get('_request_timeout'), 3773 collection_formats=collection_formats)
Returns default user level settings for a specified account
This method returns the default settings for the email notifications that signers and senders receive about envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_notification_defaults_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
get_password_rules(self, account_id, **kwargs)
3775 def get_password_rules(self, account_id, **kwargs): 3776 """ 3777 Get the password rules 3778 This method retrieves the password rules for an account. 3779 This method makes a synchronous HTTP request by default. To make an 3780 asynchronous HTTP request, please define a `callback` function 3781 to be invoked when receiving the response. 3782 >>> def callback_function(response): 3783 >>> pprint(response) 3784 >>> 3785 >>> thread = api.get_password_rules(account_id, callback=callback_function) 3786 3787 :param callback function: The callback function 3788 for asynchronous request. (optional) 3789 :param str account_id: The external account number (int) or account ID Guid. (required) 3790 :return: AccountPasswordRules 3791 If the method is called asynchronously, 3792 returns the request thread. 3793 """ 3794 kwargs['_return_http_data_only'] = True 3795 if kwargs.get('callback'): 3796 return self.get_password_rules_with_http_info(account_id, **kwargs) 3797 else: 3798 (data) = self.get_password_rules_with_http_info(account_id, **kwargs) 3799 return data
Get the password rules
This method retrieves the password rules for an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_password_rules(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
get_password_rules_with_http_info(self, account_id, **kwargs)
3801 def get_password_rules_with_http_info(self, account_id, **kwargs): 3802 """ 3803 Get the password rules 3804 This method retrieves the password rules for an account. 3805 This method makes a synchronous HTTP request by default. To make an 3806 asynchronous HTTP request, please define a `callback` function 3807 to be invoked when receiving the response. 3808 >>> def callback_function(response): 3809 >>> pprint(response) 3810 >>> 3811 >>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function) 3812 3813 :param callback function: The callback function 3814 for asynchronous request. (optional) 3815 :param str account_id: The external account number (int) or account ID Guid. (required) 3816 :return: AccountPasswordRules 3817 If the method is called asynchronously, 3818 returns the request thread. 3819 """ 3820 3821 all_params = ['account_id'] 3822 all_params.append('callback') 3823 all_params.append('_return_http_data_only') 3824 all_params.append('_preload_content') 3825 all_params.append('_request_timeout') 3826 3827 params = locals() 3828 for key, val in iteritems(params['kwargs']): 3829 if key not in all_params: 3830 raise TypeError( 3831 "Got an unexpected keyword argument '%s'" 3832 " to method get_password_rules" % key 3833 ) 3834 params[key] = val 3835 del params['kwargs'] 3836 # verify the required parameter 'account_id' is set 3837 if ('account_id' not in params) or (params['account_id'] is None): 3838 raise ValueError("Missing the required parameter `account_id` when calling `get_password_rules`") 3839 3840 3841 collection_formats = {} 3842 3843 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 3844 path_params = {} 3845 if 'account_id' in params: 3846 path_params['accountId'] = params['account_id'] 3847 3848 query_params = {} 3849 3850 header_params = {} 3851 3852 form_params = [] 3853 local_var_files = {} 3854 3855 body_params = None 3856 # HTTP header `Accept` 3857 header_params['Accept'] = self.api_client.\ 3858 select_header_accept(['application/json']) 3859 3860 # Authentication setting 3861 auth_settings = [] 3862 3863 return self.api_client.call_api(resource_path, 'GET', 3864 path_params, 3865 query_params, 3866 header_params, 3867 body=body_params, 3868 post_params=form_params, 3869 files=local_var_files, 3870 response_type='AccountPasswordRules', 3871 auth_settings=auth_settings, 3872 callback=params.get('callback'), 3873 _return_http_data_only=params.get('_return_http_data_only'), 3874 _preload_content=params.get('_preload_content', True), 3875 _request_timeout=params.get('_request_timeout'), 3876 collection_formats=collection_formats)
Get the password rules
This method retrieves the password rules for an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_password_rules_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
get_password_rules_0(self, **kwargs)
3878 def get_password_rules_0(self, **kwargs): 3879 """ 3880 Get membership account password rules 3881 3882 This method makes a synchronous HTTP request by default. To make an 3883 asynchronous HTTP request, please define a `callback` function 3884 to be invoked when receiving the response. 3885 >>> def callback_function(response): 3886 >>> pprint(response) 3887 >>> 3888 >>> thread = api.get_password_rules_0(callback=callback_function) 3889 3890 :param callback function: The callback function 3891 for asynchronous request. (optional) 3892 :return: UserPasswordRules 3893 If the method is called asynchronously, 3894 returns the request thread. 3895 """ 3896 kwargs['_return_http_data_only'] = True 3897 if kwargs.get('callback'): 3898 return self.get_password_rules_0_with_http_info(**kwargs) 3899 else: 3900 (data) = self.get_password_rules_0_with_http_info(**kwargs) 3901 return data
Get membership account password rules
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_password_rules_0(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
UserPasswordRules If the method is called asynchronously, returns the request thread.
def
get_password_rules_0_with_http_info(self, **kwargs)
3903 def get_password_rules_0_with_http_info(self, **kwargs): 3904 """ 3905 Get membership account password rules 3906 3907 This method makes a synchronous HTTP request by default. To make an 3908 asynchronous HTTP request, please define a `callback` function 3909 to be invoked when receiving the response. 3910 >>> def callback_function(response): 3911 >>> pprint(response) 3912 >>> 3913 >>> thread = api.get_password_rules_0_with_http_info(callback=callback_function) 3914 3915 :param callback function: The callback function 3916 for asynchronous request. (optional) 3917 :return: UserPasswordRules 3918 If the method is called asynchronously, 3919 returns the request thread. 3920 """ 3921 3922 all_params = [] 3923 all_params.append('callback') 3924 all_params.append('_return_http_data_only') 3925 all_params.append('_preload_content') 3926 all_params.append('_request_timeout') 3927 3928 params = locals() 3929 for key, val in iteritems(params['kwargs']): 3930 if key not in all_params: 3931 raise TypeError( 3932 "Got an unexpected keyword argument '%s'" 3933 " to method get_password_rules_0" % key 3934 ) 3935 params[key] = val 3936 del params['kwargs'] 3937 3938 collection_formats = {} 3939 3940 resource_path = '/v2.1/current_user/password_rules'.replace('{format}', 'json') 3941 path_params = {} 3942 3943 query_params = {} 3944 3945 header_params = {} 3946 3947 form_params = [] 3948 local_var_files = {} 3949 3950 body_params = None 3951 # HTTP header `Accept` 3952 header_params['Accept'] = self.api_client.\ 3953 select_header_accept(['application/json']) 3954 3955 # Authentication setting 3956 auth_settings = [] 3957 3958 return self.api_client.call_api(resource_path, 'GET', 3959 path_params, 3960 query_params, 3961 header_params, 3962 body=body_params, 3963 post_params=form_params, 3964 files=local_var_files, 3965 response_type='UserPasswordRules', 3966 auth_settings=auth_settings, 3967 callback=params.get('callback'), 3968 _return_http_data_only=params.get('_return_http_data_only'), 3969 _preload_content=params.get('_preload_content', True), 3970 _request_timeout=params.get('_request_timeout'), 3971 collection_formats=collection_formats)
Get membership account password rules
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_password_rules_0_with_http_info(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
UserPasswordRules If the method is called asynchronously, returns the request thread.
def
get_permission_profile(self, account_id, permission_profile_id, **kwargs)
3973 def get_permission_profile(self, account_id, permission_profile_id, **kwargs): 3974 """ 3975 Returns a permissions profile in the specified account. 3976 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 3977 This method makes a synchronous HTTP request by default. To make an 3978 asynchronous HTTP request, please define a `callback` function 3979 to be invoked when receiving the response. 3980 >>> def callback_function(response): 3981 >>> pprint(response) 3982 >>> 3983 >>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function) 3984 3985 :param callback function: The callback function 3986 for asynchronous request. (optional) 3987 :param str account_id: The external account number (int) or account ID Guid. (required) 3988 :param str permission_profile_id: (required) 3989 :param str include: 3990 :return: PermissionProfile 3991 If the method is called asynchronously, 3992 returns the request thread. 3993 """ 3994 kwargs['_return_http_data_only'] = True 3995 if kwargs.get('callback'): 3996 return self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 3997 else: 3998 (data) = self.get_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 3999 return data
Returns a permissions profile in the specified account.
This method returns information about a specific permission profile that is associated with an account. ### Related topics - How to set a permission profile
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
4001 def get_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 4002 """ 4003 Returns a permissions profile in the specified account. 4004 This method returns information about a specific permission profile that is associated with an account. ### Related topics - [How to set a permission profile](/docs/esign-rest-api/how-to/permission-profile-setting/) 4005 This method makes a synchronous HTTP request by default. To make an 4006 asynchronous HTTP request, please define a `callback` function 4007 to be invoked when receiving the response. 4008 >>> def callback_function(response): 4009 >>> pprint(response) 4010 >>> 4011 >>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 4012 4013 :param callback function: The callback function 4014 for asynchronous request. (optional) 4015 :param str account_id: The external account number (int) or account ID Guid. (required) 4016 :param str permission_profile_id: (required) 4017 :param str include: 4018 :return: PermissionProfile 4019 If the method is called asynchronously, 4020 returns the request thread. 4021 """ 4022 4023 all_params = ['account_id', 'permission_profile_id', 'include'] 4024 all_params.append('callback') 4025 all_params.append('_return_http_data_only') 4026 all_params.append('_preload_content') 4027 all_params.append('_request_timeout') 4028 4029 params = locals() 4030 for key, val in iteritems(params['kwargs']): 4031 if key not in all_params: 4032 raise TypeError( 4033 "Got an unexpected keyword argument '%s'" 4034 " to method get_permission_profile" % key 4035 ) 4036 params[key] = val 4037 del params['kwargs'] 4038 # verify the required parameter 'account_id' is set 4039 if ('account_id' not in params) or (params['account_id'] is None): 4040 raise ValueError("Missing the required parameter `account_id` when calling `get_permission_profile`") 4041 # verify the required parameter 'permission_profile_id' is set 4042 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 4043 raise ValueError("Missing the required parameter `permission_profile_id` when calling `get_permission_profile`") 4044 4045 4046 collection_formats = {} 4047 4048 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 4049 path_params = {} 4050 if 'account_id' in params: 4051 path_params['accountId'] = params['account_id'] 4052 if 'permission_profile_id' in params: 4053 path_params['permissionProfileId'] = params['permission_profile_id'] 4054 4055 query_params = {} 4056 if 'include' in params: 4057 query_params['include'] = params['include'] 4058 4059 header_params = {} 4060 4061 form_params = [] 4062 local_var_files = {} 4063 4064 body_params = None 4065 # HTTP header `Accept` 4066 header_params['Accept'] = self.api_client.\ 4067 select_header_accept(['application/json']) 4068 4069 # Authentication setting 4070 auth_settings = [] 4071 4072 return self.api_client.call_api(resource_path, 'GET', 4073 path_params, 4074 query_params, 4075 header_params, 4076 body=body_params, 4077 post_params=form_params, 4078 files=local_var_files, 4079 response_type='PermissionProfile', 4080 auth_settings=auth_settings, 4081 callback=params.get('callback'), 4082 _return_http_data_only=params.get('_return_http_data_only'), 4083 _preload_content=params.get('_preload_content', True), 4084 _request_timeout=params.get('_request_timeout'), 4085 collection_formats=collection_formats)
Returns a permissions profile in the specified account.
This method returns information about a specific permission profile that is associated with an account. ### Related topics - How to set a permission profile
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
get_provisioning(self, **kwargs)
4087 def get_provisioning(self, **kwargs): 4088 """ 4089 Retrieves the account provisioning information for the account. 4090 Retrieves the account provisioning information for the account. 4091 This method makes a synchronous HTTP request by default. To make an 4092 asynchronous HTTP request, please define a `callback` function 4093 to be invoked when receiving the response. 4094 >>> def callback_function(response): 4095 >>> pprint(response) 4096 >>> 4097 >>> thread = api.get_provisioning(callback=callback_function) 4098 4099 :param callback function: The callback function 4100 for asynchronous request. (optional) 4101 :return: ProvisioningInformation 4102 If the method is called asynchronously, 4103 returns the request thread. 4104 """ 4105 kwargs['_return_http_data_only'] = True 4106 if kwargs.get('callback'): 4107 return self.get_provisioning_with_http_info(**kwargs) 4108 else: 4109 (data) = self.get_provisioning_with_http_info(**kwargs) 4110 return data
Retrieves the account provisioning information for the account.
Retrieves the account provisioning information for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_provisioning(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
ProvisioningInformation If the method is called asynchronously, returns the request thread.
def
get_provisioning_with_http_info(self, **kwargs)
4112 def get_provisioning_with_http_info(self, **kwargs): 4113 """ 4114 Retrieves the account provisioning information for the account. 4115 Retrieves the account provisioning information for the account. 4116 This method makes a synchronous HTTP request by default. To make an 4117 asynchronous HTTP request, please define a `callback` function 4118 to be invoked when receiving the response. 4119 >>> def callback_function(response): 4120 >>> pprint(response) 4121 >>> 4122 >>> thread = api.get_provisioning_with_http_info(callback=callback_function) 4123 4124 :param callback function: The callback function 4125 for asynchronous request. (optional) 4126 :return: ProvisioningInformation 4127 If the method is called asynchronously, 4128 returns the request thread. 4129 """ 4130 4131 all_params = [] 4132 all_params.append('callback') 4133 all_params.append('_return_http_data_only') 4134 all_params.append('_preload_content') 4135 all_params.append('_request_timeout') 4136 4137 params = locals() 4138 for key, val in iteritems(params['kwargs']): 4139 if key not in all_params: 4140 raise TypeError( 4141 "Got an unexpected keyword argument '%s'" 4142 " to method get_provisioning" % key 4143 ) 4144 params[key] = val 4145 del params['kwargs'] 4146 4147 collection_formats = {} 4148 4149 resource_path = '/v2.1/accounts/provisioning'.replace('{format}', 'json') 4150 path_params = {} 4151 4152 query_params = {} 4153 4154 header_params = {} 4155 4156 form_params = [] 4157 local_var_files = {} 4158 4159 body_params = None 4160 # HTTP header `Accept` 4161 header_params['Accept'] = self.api_client.\ 4162 select_header_accept(['application/json']) 4163 4164 # Authentication setting 4165 auth_settings = [] 4166 4167 return self.api_client.call_api(resource_path, 'GET', 4168 path_params, 4169 query_params, 4170 header_params, 4171 body=body_params, 4172 post_params=form_params, 4173 files=local_var_files, 4174 response_type='ProvisioningInformation', 4175 auth_settings=auth_settings, 4176 callback=params.get('callback'), 4177 _return_http_data_only=params.get('_return_http_data_only'), 4178 _preload_content=params.get('_preload_content', True), 4179 _request_timeout=params.get('_request_timeout'), 4180 collection_formats=collection_formats)
Retrieves the account provisioning information for the account.
Retrieves the account provisioning information for the account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_provisioning_with_http_info(callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
Returns
ProvisioningInformation If the method is called asynchronously, returns the request thread.
def
get_supported_languages(self, account_id, **kwargs)
4182 def get_supported_languages(self, account_id, **kwargs): 4183 """ 4184 Gets list of supported languages for recipient language setting. 4185 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4186 This method makes a synchronous HTTP request by default. To make an 4187 asynchronous HTTP request, please define a `callback` function 4188 to be invoked when receiving the response. 4189 >>> def callback_function(response): 4190 >>> pprint(response) 4191 >>> 4192 >>> thread = api.get_supported_languages(account_id, callback=callback_function) 4193 4194 :param callback function: The callback function 4195 for asynchronous request. (optional) 4196 :param str account_id: The external account number (int) or account ID Guid. (required) 4197 :return: SupportedLanguages 4198 If the method is called asynchronously, 4199 returns the request thread. 4200 """ 4201 kwargs['_return_http_data_only'] = True 4202 if kwargs.get('callback'): 4203 return self.get_supported_languages_with_http_info(account_id, **kwargs) 4204 else: 4205 (data) = self.get_supported_languages_with_http_info(account_id, **kwargs) 4206 return data
Gets list of supported languages for recipient language setting.
Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. Note: Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the emailBody and emailSubject of the notification is not translated, and appears exactly as you enter it. For more information, see Set Recipient Language and Specify Custom Email Messages.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_supported_languages(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
SupportedLanguages If the method is called asynchronously, returns the request thread.
def
get_supported_languages_with_http_info(self, account_id, **kwargs)
4208 def get_supported_languages_with_http_info(self, account_id, **kwargs): 4209 """ 4210 Gets list of supported languages for recipient language setting. 4211 Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. **Note:** Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the `emailBody` and `emailSubject` of the notification is not translated, and appears exactly as you enter it. For more information, see [Set Recipient Language and Specify Custom Email Messages](https://support.docusign.com/en/guides/ndse-user-guide-recipient-language). 4212 This method makes a synchronous HTTP request by default. To make an 4213 asynchronous HTTP request, please define a `callback` function 4214 to be invoked when receiving the response. 4215 >>> def callback_function(response): 4216 >>> pprint(response) 4217 >>> 4218 >>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function) 4219 4220 :param callback function: The callback function 4221 for asynchronous request. (optional) 4222 :param str account_id: The external account number (int) or account ID Guid. (required) 4223 :return: SupportedLanguages 4224 If the method is called asynchronously, 4225 returns the request thread. 4226 """ 4227 4228 all_params = ['account_id'] 4229 all_params.append('callback') 4230 all_params.append('_return_http_data_only') 4231 all_params.append('_preload_content') 4232 all_params.append('_request_timeout') 4233 4234 params = locals() 4235 for key, val in iteritems(params['kwargs']): 4236 if key not in all_params: 4237 raise TypeError( 4238 "Got an unexpected keyword argument '%s'" 4239 " to method get_supported_languages" % key 4240 ) 4241 params[key] = val 4242 del params['kwargs'] 4243 # verify the required parameter 'account_id' is set 4244 if ('account_id' not in params) or (params['account_id'] is None): 4245 raise ValueError("Missing the required parameter `account_id` when calling `get_supported_languages`") 4246 4247 4248 collection_formats = {} 4249 4250 resource_path = '/v2.1/accounts/{accountId}/supported_languages'.replace('{format}', 'json') 4251 path_params = {} 4252 if 'account_id' in params: 4253 path_params['accountId'] = params['account_id'] 4254 4255 query_params = {} 4256 4257 header_params = {} 4258 4259 form_params = [] 4260 local_var_files = {} 4261 4262 body_params = None 4263 # HTTP header `Accept` 4264 header_params['Accept'] = self.api_client.\ 4265 select_header_accept(['application/json']) 4266 4267 # Authentication setting 4268 auth_settings = [] 4269 4270 return self.api_client.call_api(resource_path, 'GET', 4271 path_params, 4272 query_params, 4273 header_params, 4274 body=body_params, 4275 post_params=form_params, 4276 files=local_var_files, 4277 response_type='SupportedLanguages', 4278 auth_settings=auth_settings, 4279 callback=params.get('callback'), 4280 _return_http_data_only=params.get('_return_http_data_only'), 4281 _preload_content=params.get('_preload_content', True), 4282 _request_timeout=params.get('_request_timeout'), 4283 collection_formats=collection_formats)
Gets list of supported languages for recipient language setting.
Retrieves a list of supported languages that you can set for an individual recipient when creating an envelope, as well as their simple type enumeration values. These are the languages that you can set for the standard email format and signing view for each recipient. For example, in the recipient's email notification, this setting affects elements such as the standard introductory text describing the request to sign. It also determines the language used for buttons and tabs in both the email notification and the signing experience. Note: Setting a language for a recipient affects only the DocuSign standard text. Any custom text that you enter for the emailBody and emailSubject of the notification is not translated, and appears exactly as you enter it. For more information, see Set Recipient Language and Specify Custom Email Messages.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_supported_languages_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
SupportedLanguages If the method is called asynchronously, returns the request thread.
def
get_watermark(self, account_id, **kwargs)
4285 def get_watermark(self, account_id, **kwargs): 4286 """ 4287 Get watermark information. 4288 4289 This method makes a synchronous HTTP request by default. To make an 4290 asynchronous HTTP request, please define a `callback` function 4291 to be invoked when receiving the response. 4292 >>> def callback_function(response): 4293 >>> pprint(response) 4294 >>> 4295 >>> thread = api.get_watermark(account_id, callback=callback_function) 4296 4297 :param callback function: The callback function 4298 for asynchronous request. (optional) 4299 :param str account_id: The external account number (int) or account ID Guid. (required) 4300 :return: Watermark 4301 If the method is called asynchronously, 4302 returns the request thread. 4303 """ 4304 kwargs['_return_http_data_only'] = True 4305 if kwargs.get('callback'): 4306 return self.get_watermark_with_http_info(account_id, **kwargs) 4307 else: 4308 (data) = self.get_watermark_with_http_info(account_id, **kwargs) 4309 return data
Get watermark information.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_watermark(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
get_watermark_with_http_info(self, account_id, **kwargs)
4311 def get_watermark_with_http_info(self, account_id, **kwargs): 4312 """ 4313 Get watermark information. 4314 4315 This method makes a synchronous HTTP request by default. To make an 4316 asynchronous HTTP request, please define a `callback` function 4317 to be invoked when receiving the response. 4318 >>> def callback_function(response): 4319 >>> pprint(response) 4320 >>> 4321 >>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function) 4322 4323 :param callback function: The callback function 4324 for asynchronous request. (optional) 4325 :param str account_id: The external account number (int) or account ID Guid. (required) 4326 :return: Watermark 4327 If the method is called asynchronously, 4328 returns the request thread. 4329 """ 4330 4331 all_params = ['account_id'] 4332 all_params.append('callback') 4333 all_params.append('_return_http_data_only') 4334 all_params.append('_preload_content') 4335 all_params.append('_request_timeout') 4336 4337 params = locals() 4338 for key, val in iteritems(params['kwargs']): 4339 if key not in all_params: 4340 raise TypeError( 4341 "Got an unexpected keyword argument '%s'" 4342 " to method get_watermark" % key 4343 ) 4344 params[key] = val 4345 del params['kwargs'] 4346 # verify the required parameter 'account_id' is set 4347 if ('account_id' not in params) or (params['account_id'] is None): 4348 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark`") 4349 4350 4351 collection_formats = {} 4352 4353 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 4354 path_params = {} 4355 if 'account_id' in params: 4356 path_params['accountId'] = params['account_id'] 4357 4358 query_params = {} 4359 4360 header_params = {} 4361 4362 form_params = [] 4363 local_var_files = {} 4364 4365 body_params = None 4366 # HTTP header `Accept` 4367 header_params['Accept'] = self.api_client.\ 4368 select_header_accept(['application/json']) 4369 4370 # Authentication setting 4371 auth_settings = [] 4372 4373 return self.api_client.call_api(resource_path, 'GET', 4374 path_params, 4375 query_params, 4376 header_params, 4377 body=body_params, 4378 post_params=form_params, 4379 files=local_var_files, 4380 response_type='Watermark', 4381 auth_settings=auth_settings, 4382 callback=params.get('callback'), 4383 _return_http_data_only=params.get('_return_http_data_only'), 4384 _preload_content=params.get('_preload_content', True), 4385 _request_timeout=params.get('_request_timeout'), 4386 collection_formats=collection_formats)
Get watermark information.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_watermark_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
get_watermark_preview(self, account_id, **kwargs)
4388 def get_watermark_preview(self, account_id, **kwargs): 4389 """ 4390 Get watermark preview. 4391 4392 This method makes a synchronous HTTP request by default. To make an 4393 asynchronous HTTP request, please define a `callback` function 4394 to be invoked when receiving the response. 4395 >>> def callback_function(response): 4396 >>> pprint(response) 4397 >>> 4398 >>> thread = api.get_watermark_preview(account_id, callback=callback_function) 4399 4400 :param callback function: The callback function 4401 for asynchronous request. (optional) 4402 :param str account_id: The external account number (int) or account ID Guid. (required) 4403 :param Watermark watermark: 4404 :return: Watermark 4405 If the method is called asynchronously, 4406 returns the request thread. 4407 """ 4408 kwargs['_return_http_data_only'] = True 4409 if kwargs.get('callback'): 4410 return self.get_watermark_preview_with_http_info(account_id, **kwargs) 4411 else: 4412 (data) = self.get_watermark_preview_with_http_info(account_id, **kwargs) 4413 return data
Get watermark preview.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_watermark_preview(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
get_watermark_preview_with_http_info(self, account_id, **kwargs)
4415 def get_watermark_preview_with_http_info(self, account_id, **kwargs): 4416 """ 4417 Get watermark preview. 4418 4419 This method makes a synchronous HTTP request by default. To make an 4420 asynchronous HTTP request, please define a `callback` function 4421 to be invoked when receiving the response. 4422 >>> def callback_function(response): 4423 >>> pprint(response) 4424 >>> 4425 >>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function) 4426 4427 :param callback function: The callback function 4428 for asynchronous request. (optional) 4429 :param str account_id: The external account number (int) or account ID Guid. (required) 4430 :param Watermark watermark: 4431 :return: Watermark 4432 If the method is called asynchronously, 4433 returns the request thread. 4434 """ 4435 4436 all_params = ['account_id', 'watermark'] 4437 all_params.append('callback') 4438 all_params.append('_return_http_data_only') 4439 all_params.append('_preload_content') 4440 all_params.append('_request_timeout') 4441 4442 params = locals() 4443 for key, val in iteritems(params['kwargs']): 4444 if key not in all_params: 4445 raise TypeError( 4446 "Got an unexpected keyword argument '%s'" 4447 " to method get_watermark_preview" % key 4448 ) 4449 params[key] = val 4450 del params['kwargs'] 4451 # verify the required parameter 'account_id' is set 4452 if ('account_id' not in params) or (params['account_id'] is None): 4453 raise ValueError("Missing the required parameter `account_id` when calling `get_watermark_preview`") 4454 4455 4456 collection_formats = {} 4457 4458 resource_path = '/v2.1/accounts/{accountId}/watermark/preview'.replace('{format}', 'json') 4459 path_params = {} 4460 if 'account_id' in params: 4461 path_params['accountId'] = params['account_id'] 4462 4463 query_params = {} 4464 4465 header_params = {} 4466 4467 form_params = [] 4468 local_var_files = {} 4469 4470 body_params = None 4471 if 'watermark' in params: 4472 body_params = params['watermark'] 4473 # HTTP header `Accept` 4474 header_params['Accept'] = self.api_client.\ 4475 select_header_accept(['application/json']) 4476 4477 # Authentication setting 4478 auth_settings = [] 4479 4480 return self.api_client.call_api(resource_path, 'PUT', 4481 path_params, 4482 query_params, 4483 header_params, 4484 body=body_params, 4485 post_params=form_params, 4486 files=local_var_files, 4487 response_type='Watermark', 4488 auth_settings=auth_settings, 4489 callback=params.get('callback'), 4490 _return_http_data_only=params.get('_return_http_data_only'), 4491 _preload_content=params.get('_preload_content', True), 4492 _request_timeout=params.get('_request_timeout'), 4493 collection_formats=collection_formats)
Get watermark preview.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.get_watermark_preview_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
list_brands(self, account_id, **kwargs)
4495 def list_brands(self, account_id, **kwargs): 4496 """ 4497 Gets a list of brand profiles. 4498 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 4499 This method makes a synchronous HTTP request by default. To make an 4500 asynchronous HTTP request, please define a `callback` function 4501 to be invoked when receiving the response. 4502 >>> def callback_function(response): 4503 >>> pprint(response) 4504 >>> 4505 >>> thread = api.list_brands(account_id, callback=callback_function) 4506 4507 :param callback function: The callback function 4508 for asynchronous request. (optional) 4509 :param str account_id: The external account number (int) or account ID Guid. (required) 4510 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 4511 :param str include_logos: When set to **true**, returns the logos associated with the brand. 4512 :return: BrandsResponse 4513 If the method is called asynchronously, 4514 returns the request thread. 4515 """ 4516 kwargs['_return_http_data_only'] = True 4517 if kwargs.get('callback'): 4518 return self.list_brands_with_http_info(account_id, **kwargs) 4519 else: 4520 (data) = self.list_brands_with_http_info(account_id, **kwargs) 4521 return data
Gets a list of brand profiles.
Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true for the account to use this call.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_brands(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str exclude_distributor_brand: When set to true, excludes distributor brand information from the response set.
- str include_logos: When set to true, returns the logos associated with the brand.
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
list_brands_with_http_info(self, account_id, **kwargs)
4523 def list_brands_with_http_info(self, account_id, **kwargs): 4524 """ 4525 Gets a list of brand profiles. 4526 Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties `canSelfBrandSend` and `canSelfBrandSend`) must be set to **true** for the account to use this call. 4527 This method makes a synchronous HTTP request by default. To make an 4528 asynchronous HTTP request, please define a `callback` function 4529 to be invoked when receiving the response. 4530 >>> def callback_function(response): 4531 >>> pprint(response) 4532 >>> 4533 >>> thread = api.list_brands_with_http_info(account_id, callback=callback_function) 4534 4535 :param callback function: The callback function 4536 for asynchronous request. (optional) 4537 :param str account_id: The external account number (int) or account ID Guid. (required) 4538 :param str exclude_distributor_brand: When set to **true**, excludes distributor brand information from the response set. 4539 :param str include_logos: When set to **true**, returns the logos associated with the brand. 4540 :return: BrandsResponse 4541 If the method is called asynchronously, 4542 returns the request thread. 4543 """ 4544 4545 all_params = ['account_id', 'exclude_distributor_brand', 'include_logos'] 4546 all_params.append('callback') 4547 all_params.append('_return_http_data_only') 4548 all_params.append('_preload_content') 4549 all_params.append('_request_timeout') 4550 4551 params = locals() 4552 for key, val in iteritems(params['kwargs']): 4553 if key not in all_params: 4554 raise TypeError( 4555 "Got an unexpected keyword argument '%s'" 4556 " to method list_brands" % key 4557 ) 4558 params[key] = val 4559 del params['kwargs'] 4560 # verify the required parameter 'account_id' is set 4561 if ('account_id' not in params) or (params['account_id'] is None): 4562 raise ValueError("Missing the required parameter `account_id` when calling `list_brands`") 4563 4564 4565 collection_formats = {} 4566 4567 resource_path = '/v2.1/accounts/{accountId}/brands'.replace('{format}', 'json') 4568 path_params = {} 4569 if 'account_id' in params: 4570 path_params['accountId'] = params['account_id'] 4571 4572 query_params = {} 4573 if 'exclude_distributor_brand' in params: 4574 query_params['exclude_distributor_brand'] = params['exclude_distributor_brand'] 4575 if 'include_logos' in params: 4576 query_params['include_logos'] = params['include_logos'] 4577 4578 header_params = {} 4579 4580 form_params = [] 4581 local_var_files = {} 4582 4583 body_params = None 4584 # HTTP header `Accept` 4585 header_params['Accept'] = self.api_client.\ 4586 select_header_accept(['application/json']) 4587 4588 # Authentication setting 4589 auth_settings = [] 4590 4591 return self.api_client.call_api(resource_path, 'GET', 4592 path_params, 4593 query_params, 4594 header_params, 4595 body=body_params, 4596 post_params=form_params, 4597 files=local_var_files, 4598 response_type='BrandsResponse', 4599 auth_settings=auth_settings, 4600 callback=params.get('callback'), 4601 _return_http_data_only=params.get('_return_http_data_only'), 4602 _preload_content=params.get('_preload_content', True), 4603 _request_timeout=params.get('_request_timeout'), 4604 collection_formats=collection_formats)
Gets a list of brand profiles.
Retrieves the list of brand profiles associated with the account and the default brand profiles. The Account Branding feature (accountSettings properties canSelfBrandSend and canSelfBrandSend) must be set to true for the account to use this call.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_brands_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str exclude_distributor_brand: When set to true, excludes distributor brand information from the response set.
- str include_logos: When set to true, returns the logos associated with the brand.
Returns
BrandsResponse If the method is called asynchronously, returns the request thread.
def
list_custom_fields(self, account_id, **kwargs)
4606 def list_custom_fields(self, account_id, **kwargs): 4607 """ 4608 Gets a list of custom fields associated with the account. 4609 Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. 4610 This method makes a synchronous HTTP request by default. To make an 4611 asynchronous HTTP request, please define a `callback` function 4612 to be invoked when receiving the response. 4613 >>> def callback_function(response): 4614 >>> pprint(response) 4615 >>> 4616 >>> thread = api.list_custom_fields(account_id, callback=callback_function) 4617 4618 :param callback function: The callback function 4619 for asynchronous request. (optional) 4620 :param str account_id: The external account number (int) or account ID Guid. (required) 4621 :return: CustomFields 4622 If the method is called asynchronously, 4623 returns the request thread. 4624 """ 4625 kwargs['_return_http_data_only'] = True 4626 if kwargs.get('callback'): 4627 return self.list_custom_fields_with_http_info(account_id, **kwargs) 4628 else: 4629 (data) = self.list_custom_fields_with_http_info(account_id, **kwargs) 4630 return data
Gets a list of custom fields associated with the account.
Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_custom_fields(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
list_custom_fields_with_http_info(self, account_id, **kwargs)
4632 def list_custom_fields_with_http_info(self, account_id, **kwargs): 4633 """ 4634 Gets a list of custom fields associated with the account. 4635 Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide. 4636 This method makes a synchronous HTTP request by default. To make an 4637 asynchronous HTTP request, please define a `callback` function 4638 to be invoked when receiving the response. 4639 >>> def callback_function(response): 4640 >>> pprint(response) 4641 >>> 4642 >>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function) 4643 4644 :param callback function: The callback function 4645 for asynchronous request. (optional) 4646 :param str account_id: The external account number (int) or account ID Guid. (required) 4647 :return: CustomFields 4648 If the method is called asynchronously, 4649 returns the request thread. 4650 """ 4651 4652 all_params = ['account_id'] 4653 all_params.append('callback') 4654 all_params.append('_return_http_data_only') 4655 all_params.append('_preload_content') 4656 all_params.append('_request_timeout') 4657 4658 params = locals() 4659 for key, val in iteritems(params['kwargs']): 4660 if key not in all_params: 4661 raise TypeError( 4662 "Got an unexpected keyword argument '%s'" 4663 " to method list_custom_fields" % key 4664 ) 4665 params[key] = val 4666 del params['kwargs'] 4667 # verify the required parameter 'account_id' is set 4668 if ('account_id' not in params) or (params['account_id'] is None): 4669 raise ValueError("Missing the required parameter `account_id` when calling `list_custom_fields`") 4670 4671 4672 collection_formats = {} 4673 4674 resource_path = '/v2.1/accounts/{accountId}/custom_fields'.replace('{format}', 'json') 4675 path_params = {} 4676 if 'account_id' in params: 4677 path_params['accountId'] = params['account_id'] 4678 4679 query_params = {} 4680 4681 header_params = {} 4682 4683 form_params = [] 4684 local_var_files = {} 4685 4686 body_params = None 4687 # HTTP header `Accept` 4688 header_params['Accept'] = self.api_client.\ 4689 select_header_accept(['application/json']) 4690 4691 # Authentication setting 4692 auth_settings = [] 4693 4694 return self.api_client.call_api(resource_path, 'GET', 4695 path_params, 4696 query_params, 4697 header_params, 4698 body=body_params, 4699 post_params=form_params, 4700 files=local_var_files, 4701 response_type='CustomFields', 4702 auth_settings=auth_settings, 4703 callback=params.get('callback'), 4704 _return_http_data_only=params.get('_return_http_data_only'), 4705 _preload_content=params.get('_preload_content', True), 4706 _request_timeout=params.get('_request_timeout'), 4707 collection_formats=collection_formats)
Gets a list of custom fields associated with the account.
Retrieves a list of envelope custom fields associated with the account. You can use these fields in the envelopes for your account to record information about the envelope, help search for envelopes and track information. The envelope custom fields are shown in the Envelope Settings section when a user is creating an envelope in the DocuSign member console. The envelope custom fields are not seen by the envelope recipients. There are two types of envelope custom fields, text, and list. A text custom field lets the sender enter the value for the field. The list custom field lets the sender select the value of the field from a list you provide.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_custom_fields_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
list_permissions(self, account_id, **kwargs)
4709 def list_permissions(self, account_id, **kwargs): 4710 """ 4711 Gets a list of permission profiles. 4712 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 4713 This method makes a synchronous HTTP request by default. To make an 4714 asynchronous HTTP request, please define a `callback` function 4715 to be invoked when receiving the response. 4716 >>> def callback_function(response): 4717 >>> pprint(response) 4718 >>> 4719 >>> thread = api.list_permissions(account_id, callback=callback_function) 4720 4721 :param callback function: The callback function 4722 for asynchronous request. (optional) 4723 :param str account_id: The external account number (int) or account ID Guid. (required) 4724 :param str include: 4725 :return: PermissionProfileInformation 4726 If the method is called asynchronously, 4727 returns the request thread. 4728 """ 4729 kwargs['_return_http_data_only'] = True 4730 if kwargs.get('callback'): 4731 return self.list_permissions_with_http_info(account_id, **kwargs) 4732 else: 4733 (data) = self.list_permissions_with_http_info(account_id, **kwargs) 4734 return data
Gets a list of permission profiles.
Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_permissions(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include:
Returns
PermissionProfileInformation If the method is called asynchronously, returns the request thread.
def
list_permissions_with_http_info(self, account_id, **kwargs)
4736 def list_permissions_with_http_info(self, account_id, **kwargs): 4737 """ 4738 Gets a list of permission profiles. 4739 Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console. 4740 This method makes a synchronous HTTP request by default. To make an 4741 asynchronous HTTP request, please define a `callback` function 4742 to be invoked when receiving the response. 4743 >>> def callback_function(response): 4744 >>> pprint(response) 4745 >>> 4746 >>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function) 4747 4748 :param callback function: The callback function 4749 for asynchronous request. (optional) 4750 :param str account_id: The external account number (int) or account ID Guid. (required) 4751 :param str include: 4752 :return: PermissionProfileInformation 4753 If the method is called asynchronously, 4754 returns the request thread. 4755 """ 4756 4757 all_params = ['account_id', 'include'] 4758 all_params.append('callback') 4759 all_params.append('_return_http_data_only') 4760 all_params.append('_preload_content') 4761 all_params.append('_request_timeout') 4762 4763 params = locals() 4764 for key, val in iteritems(params['kwargs']): 4765 if key not in all_params: 4766 raise TypeError( 4767 "Got an unexpected keyword argument '%s'" 4768 " to method list_permissions" % key 4769 ) 4770 params[key] = val 4771 del params['kwargs'] 4772 # verify the required parameter 'account_id' is set 4773 if ('account_id' not in params) or (params['account_id'] is None): 4774 raise ValueError("Missing the required parameter `account_id` when calling `list_permissions`") 4775 4776 4777 collection_formats = {} 4778 4779 resource_path = '/v2.1/accounts/{accountId}/permission_profiles'.replace('{format}', 'json') 4780 path_params = {} 4781 if 'account_id' in params: 4782 path_params['accountId'] = params['account_id'] 4783 4784 query_params = {} 4785 if 'include' in params: 4786 query_params['include'] = params['include'] 4787 4788 header_params = {} 4789 4790 form_params = [] 4791 local_var_files = {} 4792 4793 body_params = None 4794 # HTTP header `Accept` 4795 header_params['Accept'] = self.api_client.\ 4796 select_header_accept(['application/json']) 4797 4798 # Authentication setting 4799 auth_settings = [] 4800 4801 return self.api_client.call_api(resource_path, 'GET', 4802 path_params, 4803 query_params, 4804 header_params, 4805 body=body_params, 4806 post_params=form_params, 4807 files=local_var_files, 4808 response_type='PermissionProfileInformation', 4809 auth_settings=auth_settings, 4810 callback=params.get('callback'), 4811 _return_http_data_only=params.get('_return_http_data_only'), 4812 _preload_content=params.get('_preload_content', True), 4813 _request_timeout=params.get('_request_timeout'), 4814 collection_formats=collection_formats)
Gets a list of permission profiles.
Retrieves a list of Permission Profiles. Permission Profiles are a standard set of user permissions that you can apply to individual users or users in a Group. This makes it easier to manage user permissions for a large number of users, without having to change permissions on a user-by-user basis. Currently, Permission Profiles can only be created and modified in the DocuSign console.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_permissions_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str include:
Returns
PermissionProfileInformation If the method is called asynchronously, returns the request thread.
def
list_recipient_names_by_email(self, account_id, **kwargs)
4816 def list_recipient_names_by_email(self, account_id, **kwargs): 4817 """ 4818 Gets recipient names associated with an email address. 4819 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 4820 This method makes a synchronous HTTP request by default. To make an 4821 asynchronous HTTP request, please define a `callback` function 4822 to be invoked when receiving the response. 4823 >>> def callback_function(response): 4824 >>> pprint(response) 4825 >>> 4826 >>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function) 4827 4828 :param callback function: The callback function 4829 for asynchronous request. (optional) 4830 :param str account_id: The external account number (int) or account ID Guid. (required) 4831 :param str email: The email address for the user 4832 :return: RecipientNamesResponse 4833 If the method is called asynchronously, 4834 returns the request thread. 4835 """ 4836 kwargs['_return_http_data_only'] = True 4837 if kwargs.get('callback'): 4838 return self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 4839 else: 4840 (data) = self.list_recipient_names_by_email_with_http_info(account_id, **kwargs) 4841 return data
Gets recipient names associated with an email address.
Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_recipient_names_by_email(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str email: The email address for the user
Returns
RecipientNamesResponse If the method is called asynchronously, returns the request thread.
def
list_recipient_names_by_email_with_http_info(self, account_id, **kwargs)
4843 def list_recipient_names_by_email_with_http_info(self, account_id, **kwargs): 4844 """ 4845 Gets recipient names associated with an email address. 4846 Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string. 4847 This method makes a synchronous HTTP request by default. To make an 4848 asynchronous HTTP request, please define a `callback` function 4849 to be invoked when receiving the response. 4850 >>> def callback_function(response): 4851 >>> pprint(response) 4852 >>> 4853 >>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function) 4854 4855 :param callback function: The callback function 4856 for asynchronous request. (optional) 4857 :param str account_id: The external account number (int) or account ID Guid. (required) 4858 :param str email: The email address for the user 4859 :return: RecipientNamesResponse 4860 If the method is called asynchronously, 4861 returns the request thread. 4862 """ 4863 4864 all_params = ['account_id', 'email'] 4865 all_params.append('callback') 4866 all_params.append('_return_http_data_only') 4867 all_params.append('_preload_content') 4868 all_params.append('_request_timeout') 4869 4870 params = locals() 4871 for key, val in iteritems(params['kwargs']): 4872 if key not in all_params: 4873 raise TypeError( 4874 "Got an unexpected keyword argument '%s'" 4875 " to method list_recipient_names_by_email" % key 4876 ) 4877 params[key] = val 4878 del params['kwargs'] 4879 # verify the required parameter 'account_id' is set 4880 if ('account_id' not in params) or (params['account_id'] is None): 4881 raise ValueError("Missing the required parameter `account_id` when calling `list_recipient_names_by_email`") 4882 4883 4884 collection_formats = {} 4885 4886 resource_path = '/v2.1/accounts/{accountId}/recipient_names'.replace('{format}', 'json') 4887 path_params = {} 4888 if 'account_id' in params: 4889 path_params['accountId'] = params['account_id'] 4890 4891 query_params = {} 4892 if 'email' in params: 4893 query_params['email'] = params['email'] 4894 4895 header_params = {} 4896 4897 form_params = [] 4898 local_var_files = {} 4899 4900 body_params = None 4901 # HTTP header `Accept` 4902 header_params['Accept'] = self.api_client.\ 4903 select_header_accept(['application/json']) 4904 4905 # Authentication setting 4906 auth_settings = [] 4907 4908 return self.api_client.call_api(resource_path, 'GET', 4909 path_params, 4910 query_params, 4911 header_params, 4912 body=body_params, 4913 post_params=form_params, 4914 files=local_var_files, 4915 response_type='RecipientNamesResponse', 4916 auth_settings=auth_settings, 4917 callback=params.get('callback'), 4918 _return_http_data_only=params.get('_return_http_data_only'), 4919 _preload_content=params.get('_preload_content', True), 4920 _request_timeout=params.get('_request_timeout'), 4921 collection_formats=collection_formats)
Gets recipient names associated with an email address.
Retrieves a list of recipients in the specified account that are associated with a email address supplied in the query string.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_recipient_names_by_email_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str email: The email address for the user
Returns
RecipientNamesResponse If the method is called asynchronously, returns the request thread.
def
list_settings(self, account_id, **kwargs)
4923 def list_settings(self, account_id, **kwargs): 4924 """ 4925 Gets account settings information. 4926 Retrieves the account settings information for the specified account. 4927 This method makes a synchronous HTTP request by default. To make an 4928 asynchronous HTTP request, please define a `callback` function 4929 to be invoked when receiving the response. 4930 >>> def callback_function(response): 4931 >>> pprint(response) 4932 >>> 4933 >>> thread = api.list_settings(account_id, callback=callback_function) 4934 4935 :param callback function: The callback function 4936 for asynchronous request. (optional) 4937 :param str account_id: The external account number (int) or account ID Guid. (required) 4938 :return: AccountSettingsInformation 4939 If the method is called asynchronously, 4940 returns the request thread. 4941 """ 4942 kwargs['_return_http_data_only'] = True 4943 if kwargs.get('callback'): 4944 return self.list_settings_with_http_info(account_id, **kwargs) 4945 else: 4946 (data) = self.list_settings_with_http_info(account_id, **kwargs) 4947 return data
Gets account settings information.
Retrieves the account settings information for the specified account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_settings(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountSettingsInformation If the method is called asynchronously, returns the request thread.
def
list_settings_with_http_info(self, account_id, **kwargs)
4949 def list_settings_with_http_info(self, account_id, **kwargs): 4950 """ 4951 Gets account settings information. 4952 Retrieves the account settings information for the specified account. 4953 This method makes a synchronous HTTP request by default. To make an 4954 asynchronous HTTP request, please define a `callback` function 4955 to be invoked when receiving the response. 4956 >>> def callback_function(response): 4957 >>> pprint(response) 4958 >>> 4959 >>> thread = api.list_settings_with_http_info(account_id, callback=callback_function) 4960 4961 :param callback function: The callback function 4962 for asynchronous request. (optional) 4963 :param str account_id: The external account number (int) or account ID Guid. (required) 4964 :return: AccountSettingsInformation 4965 If the method is called asynchronously, 4966 returns the request thread. 4967 """ 4968 4969 all_params = ['account_id'] 4970 all_params.append('callback') 4971 all_params.append('_return_http_data_only') 4972 all_params.append('_preload_content') 4973 all_params.append('_request_timeout') 4974 4975 params = locals() 4976 for key, val in iteritems(params['kwargs']): 4977 if key not in all_params: 4978 raise TypeError( 4979 "Got an unexpected keyword argument '%s'" 4980 " to method list_settings" % key 4981 ) 4982 params[key] = val 4983 del params['kwargs'] 4984 # verify the required parameter 'account_id' is set 4985 if ('account_id' not in params) or (params['account_id'] is None): 4986 raise ValueError("Missing the required parameter `account_id` when calling `list_settings`") 4987 4988 4989 collection_formats = {} 4990 4991 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 4992 path_params = {} 4993 if 'account_id' in params: 4994 path_params['accountId'] = params['account_id'] 4995 4996 query_params = {} 4997 4998 header_params = {} 4999 5000 form_params = [] 5001 local_var_files = {} 5002 5003 body_params = None 5004 # HTTP header `Accept` 5005 header_params['Accept'] = self.api_client.\ 5006 select_header_accept(['application/json']) 5007 5008 # Authentication setting 5009 auth_settings = [] 5010 5011 return self.api_client.call_api(resource_path, 'GET', 5012 path_params, 5013 query_params, 5014 header_params, 5015 body=body_params, 5016 post_params=form_params, 5017 files=local_var_files, 5018 response_type='AccountSettingsInformation', 5019 auth_settings=auth_settings, 5020 callback=params.get('callback'), 5021 _return_http_data_only=params.get('_return_http_data_only'), 5022 _preload_content=params.get('_preload_content', True), 5023 _request_timeout=params.get('_request_timeout'), 5024 collection_formats=collection_formats)
Gets account settings information.
Retrieves the account settings information for the specified account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_settings_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountSettingsInformation If the method is called asynchronously, returns the request thread.
def
list_signature_providers(self, account_id, **kwargs)
5161 def list_signature_providers(self, account_id, **kwargs): 5162 """ 5163 Returns Account available signature providers for specified account. 5164 Returns a list of signature providers that the specified account can use. 5165 This method makes a synchronous HTTP request by default. To make an 5166 asynchronous HTTP request, please define a `callback` function 5167 to be invoked when receiving the response. 5168 >>> def callback_function(response): 5169 >>> pprint(response) 5170 >>> 5171 >>> thread = api.list_signature_providers(account_id, callback=callback_function) 5172 5173 :param callback function: The callback function 5174 for asynchronous request. (optional) 5175 :param str account_id: The external account number (int) or account ID Guid. (required) 5176 :return: AccountSignatureProviders 5177 If the method is called asynchronously, 5178 returns the request thread. 5179 """ 5180 kwargs['_return_http_data_only'] = True 5181 if kwargs.get('callback'): 5182 return self.list_signature_providers_with_http_info(account_id, **kwargs) 5183 else: 5184 (data) = self.list_signature_providers_with_http_info(account_id, **kwargs) 5185 return data
Returns Account available signature providers for specified account.
Returns a list of signature providers that the specified account can use.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_signature_providers(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountSignatureProviders If the method is called asynchronously, returns the request thread.
def
list_signature_providers_with_http_info(self, account_id, **kwargs)
5187 def list_signature_providers_with_http_info(self, account_id, **kwargs): 5188 """ 5189 Returns Account available signature providers for specified account. 5190 Returns a list of signature providers that the specified account can use. 5191 This method makes a synchronous HTTP request by default. To make an 5192 asynchronous HTTP request, please define a `callback` function 5193 to be invoked when receiving the response. 5194 >>> def callback_function(response): 5195 >>> pprint(response) 5196 >>> 5197 >>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function) 5198 5199 :param callback function: The callback function 5200 for asynchronous request. (optional) 5201 :param str account_id: The external account number (int) or account ID Guid. (required) 5202 :return: AccountSignatureProviders 5203 If the method is called asynchronously, 5204 returns the request thread. 5205 """ 5206 5207 all_params = ['account_id'] 5208 all_params.append('callback') 5209 all_params.append('_return_http_data_only') 5210 all_params.append('_preload_content') 5211 all_params.append('_request_timeout') 5212 5213 params = locals() 5214 for key, val in iteritems(params['kwargs']): 5215 if key not in all_params: 5216 raise TypeError( 5217 "Got an unexpected keyword argument '%s'" 5218 " to method list_signature_providers" % key 5219 ) 5220 params[key] = val 5221 del params['kwargs'] 5222 # verify the required parameter 'account_id' is set 5223 if ('account_id' not in params) or (params['account_id'] is None): 5224 raise ValueError("Missing the required parameter `account_id` when calling `list_signature_providers`") 5225 5226 5227 collection_formats = {} 5228 5229 resource_path = '/v2.1/accounts/{accountId}/signatureProviders'.replace('{format}', 'json') 5230 path_params = {} 5231 if 'account_id' in params: 5232 path_params['accountId'] = params['account_id'] 5233 5234 query_params = {} 5235 5236 header_params = {} 5237 5238 form_params = [] 5239 local_var_files = {} 5240 5241 body_params = None 5242 # HTTP header `Accept` 5243 header_params['Accept'] = self.api_client.\ 5244 select_header_accept(['application/json']) 5245 5246 # Authentication setting 5247 auth_settings = [] 5248 5249 return self.api_client.call_api(resource_path, 'GET', 5250 path_params, 5251 query_params, 5252 header_params, 5253 body=body_params, 5254 post_params=form_params, 5255 files=local_var_files, 5256 response_type='AccountSignatureProviders', 5257 auth_settings=auth_settings, 5258 callback=params.get('callback'), 5259 _return_http_data_only=params.get('_return_http_data_only'), 5260 _preload_content=params.get('_preload_content', True), 5261 _request_timeout=params.get('_request_timeout'), 5262 collection_formats=collection_formats)
Returns Account available signature providers for specified account.
Returns a list of signature providers that the specified account can use.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_signature_providers_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
AccountSignatureProviders If the method is called asynchronously, returns the request thread.
def
list_unsupported_file_types(self, account_id, **kwargs)
5264 def list_unsupported_file_types(self, account_id, **kwargs): 5265 """ 5266 Gets a list of unsupported file types. 5267 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 5268 This method makes a synchronous HTTP request by default. To make an 5269 asynchronous HTTP request, please define a `callback` function 5270 to be invoked when receiving the response. 5271 >>> def callback_function(response): 5272 >>> pprint(response) 5273 >>> 5274 >>> thread = api.list_unsupported_file_types(account_id, callback=callback_function) 5275 5276 :param callback function: The callback function 5277 for asynchronous request. (optional) 5278 :param str account_id: The external account number (int) or account ID Guid. (required) 5279 :return: FileTypeList 5280 If the method is called asynchronously, 5281 returns the request thread. 5282 """ 5283 kwargs['_return_http_data_only'] = True 5284 if kwargs.get('callback'): 5285 return self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 5286 else: 5287 (data) = self.list_unsupported_file_types_with_http_info(account_id, **kwargs) 5288 return data
Gets a list of unsupported file types.
Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_unsupported_file_types(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
FileTypeList If the method is called asynchronously, returns the request thread.
def
list_unsupported_file_types_with_http_info(self, account_id, **kwargs)
5290 def list_unsupported_file_types_with_http_info(self, account_id, **kwargs): 5291 """ 5292 Gets a list of unsupported file types. 5293 Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system. 5294 This method makes a synchronous HTTP request by default. To make an 5295 asynchronous HTTP request, please define a `callback` function 5296 to be invoked when receiving the response. 5297 >>> def callback_function(response): 5298 >>> pprint(response) 5299 >>> 5300 >>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function) 5301 5302 :param callback function: The callback function 5303 for asynchronous request. (optional) 5304 :param str account_id: The external account number (int) or account ID Guid. (required) 5305 :return: FileTypeList 5306 If the method is called asynchronously, 5307 returns the request thread. 5308 """ 5309 5310 all_params = ['account_id'] 5311 all_params.append('callback') 5312 all_params.append('_return_http_data_only') 5313 all_params.append('_preload_content') 5314 all_params.append('_request_timeout') 5315 5316 params = locals() 5317 for key, val in iteritems(params['kwargs']): 5318 if key not in all_params: 5319 raise TypeError( 5320 "Got an unexpected keyword argument '%s'" 5321 " to method list_unsupported_file_types" % key 5322 ) 5323 params[key] = val 5324 del params['kwargs'] 5325 # verify the required parameter 'account_id' is set 5326 if ('account_id' not in params) or (params['account_id'] is None): 5327 raise ValueError("Missing the required parameter `account_id` when calling `list_unsupported_file_types`") 5328 5329 5330 collection_formats = {} 5331 5332 resource_path = '/v2.1/accounts/{accountId}/unsupported_file_types'.replace('{format}', 'json') 5333 path_params = {} 5334 if 'account_id' in params: 5335 path_params['accountId'] = params['account_id'] 5336 5337 query_params = {} 5338 5339 header_params = {} 5340 5341 form_params = [] 5342 local_var_files = {} 5343 5344 body_params = None 5345 # HTTP header `Accept` 5346 header_params['Accept'] = self.api_client.\ 5347 select_header_accept(['application/json']) 5348 5349 # Authentication setting 5350 auth_settings = [] 5351 5352 return self.api_client.call_api(resource_path, 'GET', 5353 path_params, 5354 query_params, 5355 header_params, 5356 body=body_params, 5357 post_params=form_params, 5358 files=local_var_files, 5359 response_type='FileTypeList', 5360 auth_settings=auth_settings, 5361 callback=params.get('callback'), 5362 _return_http_data_only=params.get('_return_http_data_only'), 5363 _preload_content=params.get('_preload_content', True), 5364 _request_timeout=params.get('_request_timeout'), 5365 collection_formats=collection_formats)
Gets a list of unsupported file types.
Retrieves a list of file types (mime-types and file-extensions) that are not supported for upload through the DocuSign system.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.list_unsupported_file_types_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
Returns
FileTypeList If the method is called asynchronously, returns the request thread.
def
un_favorite_template(self, account_id, **kwargs)
5367 def un_favorite_template(self, account_id, **kwargs): 5368 """ 5369 Unfavorite a template 5370 5371 This method makes a synchronous HTTP request by default. To make an 5372 asynchronous HTTP request, please define a `callback` function 5373 to be invoked when receiving the response. 5374 >>> def callback_function(response): 5375 >>> pprint(response) 5376 >>> 5377 >>> thread = api.un_favorite_template(account_id, callback=callback_function) 5378 5379 :param callback function: The callback function 5380 for asynchronous request. (optional) 5381 :param str account_id: The external account number (int) or account ID Guid. (required) 5382 :param FavoriteTemplatesInfo favorite_templates_info: 5383 :return: FavoriteTemplatesInfo 5384 If the method is called asynchronously, 5385 returns the request thread. 5386 """ 5387 kwargs['_return_http_data_only'] = True 5388 if kwargs.get('callback'): 5389 return self.un_favorite_template_with_http_info(account_id, **kwargs) 5390 else: 5391 (data) = self.un_favorite_template_with_http_info(account_id, **kwargs) 5392 return data
Unfavorite a template
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.un_favorite_template(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
un_favorite_template_with_http_info(self, account_id, **kwargs)
5394 def un_favorite_template_with_http_info(self, account_id, **kwargs): 5395 """ 5396 Unfavorite a template 5397 5398 This method makes a synchronous HTTP request by default. To make an 5399 asynchronous HTTP request, please define a `callback` function 5400 to be invoked when receiving the response. 5401 >>> def callback_function(response): 5402 >>> pprint(response) 5403 >>> 5404 >>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function) 5405 5406 :param callback function: The callback function 5407 for asynchronous request. (optional) 5408 :param str account_id: The external account number (int) or account ID Guid. (required) 5409 :param FavoriteTemplatesInfo favorite_templates_info: 5410 :return: FavoriteTemplatesInfo 5411 If the method is called asynchronously, 5412 returns the request thread. 5413 """ 5414 5415 all_params = ['account_id', 'favorite_templates_info'] 5416 all_params.append('callback') 5417 all_params.append('_return_http_data_only') 5418 all_params.append('_preload_content') 5419 all_params.append('_request_timeout') 5420 5421 params = locals() 5422 for key, val in iteritems(params['kwargs']): 5423 if key not in all_params: 5424 raise TypeError( 5425 "Got an unexpected keyword argument '%s'" 5426 " to method un_favorite_template" % key 5427 ) 5428 params[key] = val 5429 del params['kwargs'] 5430 # verify the required parameter 'account_id' is set 5431 if ('account_id' not in params) or (params['account_id'] is None): 5432 raise ValueError("Missing the required parameter `account_id` when calling `un_favorite_template`") 5433 5434 5435 collection_formats = {} 5436 5437 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 5438 path_params = {} 5439 if 'account_id' in params: 5440 path_params['accountId'] = params['account_id'] 5441 5442 query_params = {} 5443 5444 header_params = {} 5445 5446 form_params = [] 5447 local_var_files = {} 5448 5449 body_params = None 5450 if 'favorite_templates_info' in params: 5451 body_params = params['favorite_templates_info'] 5452 # HTTP header `Accept` 5453 header_params['Accept'] = self.api_client.\ 5454 select_header_accept(['application/json']) 5455 5456 # Authentication setting 5457 auth_settings = [] 5458 5459 return self.api_client.call_api(resource_path, 'DELETE', 5460 path_params, 5461 query_params, 5462 header_params, 5463 body=body_params, 5464 post_params=form_params, 5465 files=local_var_files, 5466 response_type='FavoriteTemplatesInfo', 5467 auth_settings=auth_settings, 5468 callback=params.get('callback'), 5469 _return_http_data_only=params.get('_return_http_data_only'), 5470 _preload_content=params.get('_preload_content', True), 5471 _request_timeout=params.get('_request_timeout'), 5472 collection_formats=collection_formats)
Unfavorite a template
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.un_favorite_template_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
update_account_signature(self, account_id, **kwargs)
5474 def update_account_signature(self, account_id, **kwargs): 5475 """ 5476 Updates a account signature. 5477 5478 This method makes a synchronous HTTP request by default. To make an 5479 asynchronous HTTP request, please define a `callback` function 5480 to be invoked when receiving the response. 5481 >>> def callback_function(response): 5482 >>> pprint(response) 5483 >>> 5484 >>> thread = api.update_account_signature(account_id, callback=callback_function) 5485 5486 :param callback function: The callback function 5487 for asynchronous request. (optional) 5488 :param str account_id: The external account number (int) or account ID Guid. (required) 5489 :param AccountSignaturesInformation account_signatures_information: 5490 :return: AccountSignaturesInformation 5491 If the method is called asynchronously, 5492 returns the request thread. 5493 """ 5494 kwargs['_return_http_data_only'] = True 5495 if kwargs.get('callback'): 5496 return self.update_account_signature_with_http_info(account_id, **kwargs) 5497 else: 5498 (data) = self.update_account_signature_with_http_info(account_id, **kwargs) 5499 return data
Updates a account signature.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_signature(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
update_account_signature_with_http_info(self, account_id, **kwargs)
5501 def update_account_signature_with_http_info(self, account_id, **kwargs): 5502 """ 5503 Updates a account signature. 5504 5505 This method makes a synchronous HTTP request by default. To make an 5506 asynchronous HTTP request, please define a `callback` function 5507 to be invoked when receiving the response. 5508 >>> def callback_function(response): 5509 >>> pprint(response) 5510 >>> 5511 >>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function) 5512 5513 :param callback function: The callback function 5514 for asynchronous request. (optional) 5515 :param str account_id: The external account number (int) or account ID Guid. (required) 5516 :param AccountSignaturesInformation account_signatures_information: 5517 :return: AccountSignaturesInformation 5518 If the method is called asynchronously, 5519 returns the request thread. 5520 """ 5521 5522 all_params = ['account_id', 'account_signatures_information'] 5523 all_params.append('callback') 5524 all_params.append('_return_http_data_only') 5525 all_params.append('_preload_content') 5526 all_params.append('_request_timeout') 5527 5528 params = locals() 5529 for key, val in iteritems(params['kwargs']): 5530 if key not in all_params: 5531 raise TypeError( 5532 "Got an unexpected keyword argument '%s'" 5533 " to method update_account_signature" % key 5534 ) 5535 params[key] = val 5536 del params['kwargs'] 5537 # verify the required parameter 'account_id' is set 5538 if ('account_id' not in params) or (params['account_id'] is None): 5539 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature`") 5540 5541 5542 collection_formats = {} 5543 5544 resource_path = '/v2.1/accounts/{accountId}/signatures'.replace('{format}', 'json') 5545 path_params = {} 5546 if 'account_id' in params: 5547 path_params['accountId'] = params['account_id'] 5548 5549 query_params = {} 5550 5551 header_params = {} 5552 5553 form_params = [] 5554 local_var_files = {} 5555 5556 body_params = None 5557 if 'account_signatures_information' in params: 5558 body_params = params['account_signatures_information'] 5559 # HTTP header `Accept` 5560 header_params['Accept'] = self.api_client.\ 5561 select_header_accept(['application/json']) 5562 5563 # Authentication setting 5564 auth_settings = [] 5565 5566 return self.api_client.call_api(resource_path, 'PUT', 5567 path_params, 5568 query_params, 5569 header_params, 5570 body=body_params, 5571 post_params=form_params, 5572 files=local_var_files, 5573 response_type='AccountSignaturesInformation', 5574 auth_settings=auth_settings, 5575 callback=params.get('callback'), 5576 _return_http_data_only=params.get('_return_http_data_only'), 5577 _preload_content=params.get('_preload_content', True), 5578 _request_timeout=params.get('_request_timeout'), 5579 collection_formats=collection_formats)
Updates a account signature.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_signature_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- AccountSignaturesInformation account_signatures_information:
Returns
AccountSignaturesInformation If the method is called asynchronously, returns the request thread.
def
update_account_signature_by_id(self, account_id, signature_id, **kwargs)
5581 def update_account_signature_by_id(self, account_id, signature_id, **kwargs): 5582 """ 5583 Updates a account signature. 5584 5585 This method makes a synchronous HTTP request by default. To make an 5586 asynchronous HTTP request, please define a `callback` function 5587 to be invoked when receiving the response. 5588 >>> def callback_function(response): 5589 >>> pprint(response) 5590 >>> 5591 >>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function) 5592 5593 :param callback function: The callback function 5594 for asynchronous request. (optional) 5595 :param str account_id: The external account number (int) or account ID Guid. (required) 5596 :param str signature_id: The ID of the signature being accessed. (required) 5597 :param str close_existing_signature: 5598 :param AccountSignatureDefinition account_signature_definition: 5599 :return: AccountSignature 5600 If the method is called asynchronously, 5601 returns the request thread. 5602 """ 5603 kwargs['_return_http_data_only'] = True 5604 if kwargs.get('callback'): 5605 return self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 5606 else: 5607 (data) = self.update_account_signature_by_id_with_http_info(account_id, signature_id, **kwargs) 5608 return data
Updates a account signature.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_signature_by_id(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str close_existing_signature:
- AccountSignatureDefinition account_signature_definition:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs)
5610 def update_account_signature_by_id_with_http_info(self, account_id, signature_id, **kwargs): 5611 """ 5612 Updates a account signature. 5613 5614 This method makes a synchronous HTTP request by default. To make an 5615 asynchronous HTTP request, please define a `callback` function 5616 to be invoked when receiving the response. 5617 >>> def callback_function(response): 5618 >>> pprint(response) 5619 >>> 5620 >>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function) 5621 5622 :param callback function: The callback function 5623 for asynchronous request. (optional) 5624 :param str account_id: The external account number (int) or account ID Guid. (required) 5625 :param str signature_id: The ID of the signature being accessed. (required) 5626 :param str close_existing_signature: 5627 :param AccountSignatureDefinition account_signature_definition: 5628 :return: AccountSignature 5629 If the method is called asynchronously, 5630 returns the request thread. 5631 """ 5632 5633 all_params = ['account_id', 'signature_id', 'close_existing_signature', 'account_signature_definition'] 5634 all_params.append('callback') 5635 all_params.append('_return_http_data_only') 5636 all_params.append('_preload_content') 5637 all_params.append('_request_timeout') 5638 5639 params = locals() 5640 for key, val in iteritems(params['kwargs']): 5641 if key not in all_params: 5642 raise TypeError( 5643 "Got an unexpected keyword argument '%s'" 5644 " to method update_account_signature_by_id" % key 5645 ) 5646 params[key] = val 5647 del params['kwargs'] 5648 # verify the required parameter 'account_id' is set 5649 if ('account_id' not in params) or (params['account_id'] is None): 5650 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_by_id`") 5651 # verify the required parameter 'signature_id' is set 5652 if ('signature_id' not in params) or (params['signature_id'] is None): 5653 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_by_id`") 5654 5655 5656 collection_formats = {} 5657 5658 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}'.replace('{format}', 'json') 5659 path_params = {} 5660 if 'account_id' in params: 5661 path_params['accountId'] = params['account_id'] 5662 if 'signature_id' in params: 5663 path_params['signatureId'] = params['signature_id'] 5664 5665 query_params = {} 5666 if 'close_existing_signature' in params: 5667 query_params['close_existing_signature'] = params['close_existing_signature'] 5668 5669 header_params = {} 5670 5671 form_params = [] 5672 local_var_files = {} 5673 5674 body_params = None 5675 if 'account_signature_definition' in params: 5676 body_params = params['account_signature_definition'] 5677 # HTTP header `Accept` 5678 header_params['Accept'] = self.api_client.\ 5679 select_header_accept(['application/json']) 5680 5681 # Authentication setting 5682 auth_settings = [] 5683 5684 return self.api_client.call_api(resource_path, 'PUT', 5685 path_params, 5686 query_params, 5687 header_params, 5688 body=body_params, 5689 post_params=form_params, 5690 files=local_var_files, 5691 response_type='AccountSignature', 5692 auth_settings=auth_settings, 5693 callback=params.get('callback'), 5694 _return_http_data_only=params.get('_return_http_data_only'), 5695 _preload_content=params.get('_preload_content', True), 5696 _request_timeout=params.get('_request_timeout'), 5697 collection_formats=collection_formats)
Updates a account signature.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_signature_by_id_with_http_info(account_id, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str close_existing_signature:
- AccountSignatureDefinition account_signature_definition:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_signature_image(self, account_id, image_type, signature_id, **kwargs)
5699 def update_account_signature_image(self, account_id, image_type, signature_id, **kwargs): 5700 """ 5701 Sets a signature, initials, or stamps image. 5702 5703 This method makes a synchronous HTTP request by default. To make an 5704 asynchronous HTTP request, please define a `callback` function 5705 to be invoked when receiving the response. 5706 >>> def callback_function(response): 5707 >>> pprint(response) 5708 >>> 5709 >>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function) 5710 5711 :param callback function: The callback function 5712 for asynchronous request. (optional) 5713 :param str account_id: The external account number (int) or account ID Guid. (required) 5714 :param str image_type: One of **signature_image** or **initials_image**. (required) 5715 :param str signature_id: The ID of the signature being accessed. (required) 5716 :param str transparent_png: 5717 :return: AccountSignature 5718 If the method is called asynchronously, 5719 returns the request thread. 5720 """ 5721 kwargs['_return_http_data_only'] = True 5722 if kwargs.get('callback'): 5723 return self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 5724 else: 5725 (data) = self.update_account_signature_image_with_http_info(account_id, image_type, signature_id, **kwargs) 5726 return data
Sets a signature, initials, or stamps image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_signature_image(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str transparent_png:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs)
5728 def update_account_signature_image_with_http_info(self, account_id, image_type, signature_id, **kwargs): 5729 """ 5730 Sets a signature, initials, or stamps image. 5731 5732 This method makes a synchronous HTTP request by default. To make an 5733 asynchronous HTTP request, please define a `callback` function 5734 to be invoked when receiving the response. 5735 >>> def callback_function(response): 5736 >>> pprint(response) 5737 >>> 5738 >>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function) 5739 5740 :param callback function: The callback function 5741 for asynchronous request. (optional) 5742 :param str account_id: The external account number (int) or account ID Guid. (required) 5743 :param str image_type: One of **signature_image** or **initials_image**. (required) 5744 :param str signature_id: The ID of the signature being accessed. (required) 5745 :param str transparent_png: 5746 :return: AccountSignature 5747 If the method is called asynchronously, 5748 returns the request thread. 5749 """ 5750 5751 all_params = ['account_id', 'image_type', 'signature_id', 'transparent_png'] 5752 all_params.append('callback') 5753 all_params.append('_return_http_data_only') 5754 all_params.append('_preload_content') 5755 all_params.append('_request_timeout') 5756 5757 params = locals() 5758 for key, val in iteritems(params['kwargs']): 5759 if key not in all_params: 5760 raise TypeError( 5761 "Got an unexpected keyword argument '%s'" 5762 " to method update_account_signature_image" % key 5763 ) 5764 params[key] = val 5765 del params['kwargs'] 5766 # verify the required parameter 'account_id' is set 5767 if ('account_id' not in params) or (params['account_id'] is None): 5768 raise ValueError("Missing the required parameter `account_id` when calling `update_account_signature_image`") 5769 # verify the required parameter 'image_type' is set 5770 if ('image_type' not in params) or (params['image_type'] is None): 5771 raise ValueError("Missing the required parameter `image_type` when calling `update_account_signature_image`") 5772 # verify the required parameter 'signature_id' is set 5773 if ('signature_id' not in params) or (params['signature_id'] is None): 5774 raise ValueError("Missing the required parameter `signature_id` when calling `update_account_signature_image`") 5775 5776 5777 collection_formats = {} 5778 5779 resource_path = '/v2.1/accounts/{accountId}/signatures/{signatureId}/{imageType}'.replace('{format}', 'json') 5780 path_params = {} 5781 if 'account_id' in params: 5782 path_params['accountId'] = params['account_id'] 5783 if 'image_type' in params: 5784 path_params['imageType'] = params['image_type'] 5785 if 'signature_id' in params: 5786 path_params['signatureId'] = params['signature_id'] 5787 5788 query_params = {} 5789 if 'transparent_png' in params: 5790 query_params['transparent_png'] = params['transparent_png'] 5791 5792 header_params = {} 5793 5794 form_params = [] 5795 local_var_files = {} 5796 5797 body_params = None 5798 # HTTP header `Accept` 5799 header_params['Accept'] = self.api_client.\ 5800 select_header_accept(['application/json']) 5801 5802 # HTTP header `Content-Type` 5803 header_params['Content-Type'] = self.api_client.\ 5804 select_header_content_type(['image/gif']) 5805 5806 # Authentication setting 5807 auth_settings = [] 5808 5809 return self.api_client.call_api(resource_path, 'PUT', 5810 path_params, 5811 query_params, 5812 header_params, 5813 body=body_params, 5814 post_params=form_params, 5815 files=local_var_files, 5816 response_type='AccountSignature', 5817 auth_settings=auth_settings, 5818 callback=params.get('callback'), 5819 _return_http_data_only=params.get('_return_http_data_only'), 5820 _preload_content=params.get('_preload_content', True), 5821 _request_timeout=params.get('_request_timeout'), 5822 collection_formats=collection_formats)
Sets a signature, initials, or stamps image.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_signature_image_with_http_info(account_id, image_type, signature_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str image_type: One of signature_image or initials_image. (required)
- str signature_id: The ID of the signature being accessed. (required)
- str transparent_png:
Returns
AccountSignature If the method is called asynchronously, returns the request thread.
def
update_account_tab_settings(self, account_id, **kwargs)
5824 def update_account_tab_settings(self, account_id, **kwargs): 5825 """ 5826 Modifies tab settings for specified account 5827 This method modifies the tab types and tab functionality that is enabled for an account. 5828 This method makes a synchronous HTTP request by default. To make an 5829 asynchronous HTTP request, please define a `callback` function 5830 to be invoked when receiving the response. 5831 >>> def callback_function(response): 5832 >>> pprint(response) 5833 >>> 5834 >>> thread = api.update_account_tab_settings(account_id, callback=callback_function) 5835 5836 :param callback function: The callback function 5837 for asynchronous request. (optional) 5838 :param str account_id: The external account number (int) or account ID Guid. (required) 5839 :param TabAccountSettings tab_account_settings: 5840 :return: TabAccountSettings 5841 If the method is called asynchronously, 5842 returns the request thread. 5843 """ 5844 kwargs['_return_http_data_only'] = True 5845 if kwargs.get('callback'): 5846 return self.update_account_tab_settings_with_http_info(account_id, **kwargs) 5847 else: 5848 (data) = self.update_account_tab_settings_with_http_info(account_id, **kwargs) 5849 return data
Modifies tab settings for specified account
This method modifies the tab types and tab functionality that is enabled for an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_tab_settings(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- TabAccountSettings tab_account_settings:
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
update_account_tab_settings_with_http_info(self, account_id, **kwargs)
5851 def update_account_tab_settings_with_http_info(self, account_id, **kwargs): 5852 """ 5853 Modifies tab settings for specified account 5854 This method modifies the tab types and tab functionality that is enabled for an account. 5855 This method makes a synchronous HTTP request by default. To make an 5856 asynchronous HTTP request, please define a `callback` function 5857 to be invoked when receiving the response. 5858 >>> def callback_function(response): 5859 >>> pprint(response) 5860 >>> 5861 >>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function) 5862 5863 :param callback function: The callback function 5864 for asynchronous request. (optional) 5865 :param str account_id: The external account number (int) or account ID Guid. (required) 5866 :param TabAccountSettings tab_account_settings: 5867 :return: TabAccountSettings 5868 If the method is called asynchronously, 5869 returns the request thread. 5870 """ 5871 5872 all_params = ['account_id', 'tab_account_settings'] 5873 all_params.append('callback') 5874 all_params.append('_return_http_data_only') 5875 all_params.append('_preload_content') 5876 all_params.append('_request_timeout') 5877 5878 params = locals() 5879 for key, val in iteritems(params['kwargs']): 5880 if key not in all_params: 5881 raise TypeError( 5882 "Got an unexpected keyword argument '%s'" 5883 " to method update_account_tab_settings" % key 5884 ) 5885 params[key] = val 5886 del params['kwargs'] 5887 # verify the required parameter 'account_id' is set 5888 if ('account_id' not in params) or (params['account_id'] is None): 5889 raise ValueError("Missing the required parameter `account_id` when calling `update_account_tab_settings`") 5890 5891 5892 collection_formats = {} 5893 5894 resource_path = '/v2.1/accounts/{accountId}/settings/tabs'.replace('{format}', 'json') 5895 path_params = {} 5896 if 'account_id' in params: 5897 path_params['accountId'] = params['account_id'] 5898 5899 query_params = {} 5900 5901 header_params = {} 5902 5903 form_params = [] 5904 local_var_files = {} 5905 5906 body_params = None 5907 if 'tab_account_settings' in params: 5908 body_params = params['tab_account_settings'] 5909 # HTTP header `Accept` 5910 header_params['Accept'] = self.api_client.\ 5911 select_header_accept(['application/json']) 5912 5913 # Authentication setting 5914 auth_settings = [] 5915 5916 return self.api_client.call_api(resource_path, 'PUT', 5917 path_params, 5918 query_params, 5919 header_params, 5920 body=body_params, 5921 post_params=form_params, 5922 files=local_var_files, 5923 response_type='TabAccountSettings', 5924 auth_settings=auth_settings, 5925 callback=params.get('callback'), 5926 _return_http_data_only=params.get('_return_http_data_only'), 5927 _preload_content=params.get('_preload_content', True), 5928 _request_timeout=params.get('_request_timeout'), 5929 collection_formats=collection_formats)
Modifies tab settings for specified account
This method modifies the tab types and tab functionality that is enabled for an account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_account_tab_settings_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- TabAccountSettings tab_account_settings:
Returns
TabAccountSettings If the method is called asynchronously, returns the request thread.
def
update_brand(self, account_id, brand_id, **kwargs)
5931 def update_brand(self, account_id, brand_id, **kwargs): 5932 """ 5933 Updates an existing brand. 5934 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 5935 This method makes a synchronous HTTP request by default. To make an 5936 asynchronous HTTP request, please define a `callback` function 5937 to be invoked when receiving the response. 5938 >>> def callback_function(response): 5939 >>> pprint(response) 5940 >>> 5941 >>> thread = api.update_brand(account_id, brand_id, callback=callback_function) 5942 5943 :param callback function: The callback function 5944 for asynchronous request. (optional) 5945 :param str account_id: The external account number (int) or account ID Guid. (required) 5946 :param str brand_id: The unique identifier of a brand. (required) 5947 :param str replace_brand: 5948 :param Brand brand: 5949 :return: Brand 5950 If the method is called asynchronously, 5951 returns the request thread. 5952 """ 5953 kwargs['_return_http_data_only'] = True 5954 if kwargs.get('callback'): 5955 return self.update_brand_with_http_info(account_id, brand_id, **kwargs) 5956 else: 5957 (data) = self.update_brand_with_http_info(account_id, brand_id, **kwargs) 5958 return data
Updates an existing brand.
This method updates an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_brand(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str replace_brand:
- Brand brand:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
update_brand_with_http_info(self, account_id, brand_id, **kwargs)
5960 def update_brand_with_http_info(self, account_id, brand_id, **kwargs): 5961 """ 5962 Updates an existing brand. 5963 This method updates an account brand. **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 5964 This method makes a synchronous HTTP request by default. To make an 5965 asynchronous HTTP request, please define a `callback` function 5966 to be invoked when receiving the response. 5967 >>> def callback_function(response): 5968 >>> pprint(response) 5969 >>> 5970 >>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function) 5971 5972 :param callback function: The callback function 5973 for asynchronous request. (optional) 5974 :param str account_id: The external account number (int) or account ID Guid. (required) 5975 :param str brand_id: The unique identifier of a brand. (required) 5976 :param str replace_brand: 5977 :param Brand brand: 5978 :return: Brand 5979 If the method is called asynchronously, 5980 returns the request thread. 5981 """ 5982 5983 all_params = ['account_id', 'brand_id', 'replace_brand', 'brand'] 5984 all_params.append('callback') 5985 all_params.append('_return_http_data_only') 5986 all_params.append('_preload_content') 5987 all_params.append('_request_timeout') 5988 5989 params = locals() 5990 for key, val in iteritems(params['kwargs']): 5991 if key not in all_params: 5992 raise TypeError( 5993 "Got an unexpected keyword argument '%s'" 5994 " to method update_brand" % key 5995 ) 5996 params[key] = val 5997 del params['kwargs'] 5998 # verify the required parameter 'account_id' is set 5999 if ('account_id' not in params) or (params['account_id'] is None): 6000 raise ValueError("Missing the required parameter `account_id` when calling `update_brand`") 6001 # verify the required parameter 'brand_id' is set 6002 if ('brand_id' not in params) or (params['brand_id'] is None): 6003 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand`") 6004 6005 6006 collection_formats = {} 6007 6008 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}'.replace('{format}', 'json') 6009 path_params = {} 6010 if 'account_id' in params: 6011 path_params['accountId'] = params['account_id'] 6012 if 'brand_id' in params: 6013 path_params['brandId'] = params['brand_id'] 6014 6015 query_params = {} 6016 if 'replace_brand' in params: 6017 query_params['replace_brand'] = params['replace_brand'] 6018 6019 header_params = {} 6020 6021 form_params = [] 6022 local_var_files = {} 6023 6024 body_params = None 6025 if 'brand' in params: 6026 body_params = params['brand'] 6027 # HTTP header `Accept` 6028 header_params['Accept'] = self.api_client.\ 6029 select_header_accept(['application/json']) 6030 6031 # Authentication setting 6032 auth_settings = [] 6033 6034 return self.api_client.call_api(resource_path, 'PUT', 6035 path_params, 6036 query_params, 6037 header_params, 6038 body=body_params, 6039 post_params=form_params, 6040 files=local_var_files, 6041 response_type='Brand', 6042 auth_settings=auth_settings, 6043 callback=params.get('callback'), 6044 _return_http_data_only=params.get('_return_http_data_only'), 6045 _preload_content=params.get('_preload_content', True), 6046 _request_timeout=params.get('_request_timeout'), 6047 collection_formats=collection_formats)
Updates an existing brand.
This method updates an account brand. Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_brand_with_http_info(account_id, brand_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str brand_id: The unique identifier of a brand. (required)
- str replace_brand:
- Brand brand:
Returns
Brand If the method is called asynchronously, returns the request thread.
def
update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6049 def update_brand_logo_by_type(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6050 """ 6051 Put one branding logo. 6052 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6053 This method makes a synchronous HTTP request by default. To make an 6054 asynchronous HTTP request, please define a `callback` function 6055 to be invoked when receiving the response. 6056 >>> def callback_function(response): 6057 >>> pprint(response) 6058 >>> 6059 >>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6060 6061 :param callback function: The callback function 6062 for asynchronous request. (optional) 6063 :param str account_id: The external account number (int) or account ID GUID. (required) 6064 :param str brand_id: The ID of the brand. (required) 6065 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6066 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6067 :return: None 6068 If the method is called asynchronously, 6069 returns the request thread. 6070 """ 6071 kwargs['_return_http_data_only'] = True 6072 if kwargs.get('callback'): 6073 return self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6074 else: 6075 (data) = self.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, **kwargs) 6076 return data
Put one branding logo.
This method updates a single brand logo. You pass in the new version of the resource in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="logo.jpg" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_brand_logo_by_type(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- str brand_id: The ID of the brand. (required)
- str logo_type: The type of logo. Valid values are: -
primary-secondary-email(required) - str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs)
6078 def update_brand_logo_by_type_with_http_info(self, account_id, brand_id, logo_type, logo_file_bytes, **kwargs): 6079 """ 6080 Put one branding logo. 6081 This method updates a single brand logo. You pass in the new version of the resource in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"logo.jpg\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). 6082 This method makes a synchronous HTTP request by default. To make an 6083 asynchronous HTTP request, please define a `callback` function 6084 to be invoked when receiving the response. 6085 >>> def callback_function(response): 6086 >>> pprint(response) 6087 >>> 6088 >>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function) 6089 6090 :param callback function: The callback function 6091 for asynchronous request. (optional) 6092 :param str account_id: The external account number (int) or account ID GUID. (required) 6093 :param str brand_id: The ID of the brand. (required) 6094 :param str logo_type: The type of logo. Valid values are: - `primary` - `secondary` - `email` (required) 6095 :param str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required) 6096 :return: None 6097 If the method is called asynchronously, 6098 returns the request thread. 6099 """ 6100 6101 all_params = ['account_id', 'brand_id', 'logo_type', 'logo_file_bytes'] 6102 all_params.append('callback') 6103 all_params.append('_return_http_data_only') 6104 all_params.append('_preload_content') 6105 all_params.append('_request_timeout') 6106 6107 params = locals() 6108 for key, val in iteritems(params['kwargs']): 6109 if key not in all_params: 6110 raise TypeError( 6111 "Got an unexpected keyword argument '%s'" 6112 " to method update_brand_logo_by_type" % key 6113 ) 6114 params[key] = val 6115 del params['kwargs'] 6116 # verify the required parameter 'account_id' is set 6117 if ('account_id' not in params) or (params['account_id'] is None): 6118 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_logo_by_type`") 6119 # verify the required parameter 'brand_id' is set 6120 if ('brand_id' not in params) or (params['brand_id'] is None): 6121 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_logo_by_type`") 6122 # verify the required parameter 'logo_type' is set 6123 if ('logo_type' not in params) or (params['logo_type'] is None): 6124 raise ValueError("Missing the required parameter `logo_type` when calling `update_brand_logo_by_type`") 6125 # verify the required parameter 'logo_file_bytes' is set 6126 if ('logo_file_bytes' not in params) or (params['logo_file_bytes'] is None): 6127 raise ValueError("Missing the required parameter `logo_file_bytes` when calling `update_brand_logo_by_type`") 6128 6129 6130 collection_formats = {} 6131 6132 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/logos/{logoType}'.replace('{format}', 'json') 6133 path_params = {} 6134 if 'account_id' in params: 6135 path_params['accountId'] = params['account_id'] 6136 if 'brand_id' in params: 6137 path_params['brandId'] = params['brand_id'] 6138 if 'logo_type' in params: 6139 path_params['logoType'] = params['logo_type'] 6140 6141 query_params = {} 6142 6143 header_params = {} 6144 6145 form_params = [] 6146 local_var_files = {} 6147 6148 body_params = None 6149 if 'logo_file_bytes' in params: 6150 body_params = params['logo_file_bytes'] 6151 # HTTP header `Accept` 6152 header_params['Accept'] = self.api_client.\ 6153 select_header_accept(['application/json']) 6154 6155 # HTTP header `Content-Type` 6156 header_params['Content-Type'] = self.api_client.\ 6157 select_header_content_type(['image/png']) 6158 6159 # Authentication setting 6160 auth_settings = [] 6161 6162 return self.api_client.call_api(resource_path, 'PUT', 6163 path_params, 6164 query_params, 6165 header_params, 6166 body=body_params, 6167 post_params=form_params, 6168 files=local_var_files, 6169 response_type=None, 6170 auth_settings=auth_settings, 6171 callback=params.get('callback'), 6172 _return_http_data_only=params.get('_return_http_data_only'), 6173 _preload_content=params.get('_preload_content', True), 6174 _request_timeout=params.get('_request_timeout'), 6175 collection_formats=collection_formats)
Put one branding logo.
This method updates a single brand logo. You pass in the new version of the resource in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="logo.jpg" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true).
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_brand_logo_by_type_with_http_info(account_id, brand_id, logo_type, logo_file_bytes, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- str brand_id: The ID of the brand. (required)
- str logo_type: The type of logo. Valid values are: -
primary-secondary-email(required) - str logo_file_bytes: Brand logo binary Stream. Supported formats: JPG, GIF, PNG. Maximum file size: 300 KB. Recommended dimensions: 296 x 76 pixels (larger images will be resized). Changes may take up to one hour to display in all places (required)
Returns
None If the method is called asynchronously, returns the request thread.
def
update_brand_resources_by_content_type( self, account_id, brand_id, resource_content_type, file_xml, **kwargs)
6177 def update_brand_resources_by_content_type(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 6178 """ 6179 Uploads a branding resource file. 6180 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 6181 This method makes a synchronous HTTP request by default. To make an 6182 asynchronous HTTP request, please define a `callback` function 6183 to be invoked when receiving the response. 6184 >>> def callback_function(response): 6185 >>> pprint(response) 6186 >>> 6187 >>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 6188 6189 :param callback function: The callback function 6190 for asynchronous request. (optional) 6191 :param str account_id: The external account number (int) or account ID GUID. (required) 6192 :param str brand_id: The ID of the brand. (required) 6193 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 6194 :param file file_xml: Brand resource XML file. (required) 6195 :return: BrandResources 6196 If the method is called asynchronously, 6197 returns the request thread. 6198 """ 6199 kwargs['_return_http_data_only'] = True 6200 if kwargs.get('callback'): 6201 return self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 6202 else: 6203 (data) = self.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, **kwargs) 6204 return data
Uploads a branding resource file.
This method updates a branding resource file. You pass in the new version of the resource file in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="DocuSign_SigningResource_4328673.xml" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). Important: Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_brand_resources_by_content_type(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- str brand_id: The ID of the brand. (required)
- str resource_content_type: The type of brand resource file that you are updating. Valid values are: -
sending-signing-email-signing_captive(required) - file file_xml: Brand resource XML file. (required)
Returns
BrandResources If the method is called asynchronously, returns the request thread.
def
update_brand_resources_by_content_type_with_http_info( self, account_id, brand_id, resource_content_type, file_xml, **kwargs)
6206 def update_brand_resources_by_content_type_with_http_info(self, account_id, brand_id, resource_content_type, file_xml, **kwargs): 6207 """ 6208 Uploads a branding resource file. 6209 This method updates a branding resource file. You pass in the new version of the resource file in the `Content-Disposition` header. Example: `Content-Disposition: form-data; name=\"file\"; filename=\"DocuSign_SigningResource_4328673.xml\"` **Note:** Branding for either signing or sending must be enabled for the account (`canSelfBrandSend` , `canSelfBrandSign`, or both of these account settings must be **true**). **Important:** Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file. 6210 This method makes a synchronous HTTP request by default. To make an 6211 asynchronous HTTP request, please define a `callback` function 6212 to be invoked when receiving the response. 6213 >>> def callback_function(response): 6214 >>> pprint(response) 6215 >>> 6216 >>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function) 6217 6218 :param callback function: The callback function 6219 for asynchronous request. (optional) 6220 :param str account_id: The external account number (int) or account ID GUID. (required) 6221 :param str brand_id: The ID of the brand. (required) 6222 :param str resource_content_type: The type of brand resource file that you are updating. Valid values are: - `sending` - `signing` - `email` - `signing_captive` (required) 6223 :param file file_xml: Brand resource XML file. (required) 6224 :return: BrandResources 6225 If the method is called asynchronously, 6226 returns the request thread. 6227 """ 6228 6229 all_params = ['account_id', 'brand_id', 'resource_content_type', 'file_xml'] 6230 all_params.append('callback') 6231 all_params.append('_return_http_data_only') 6232 all_params.append('_preload_content') 6233 all_params.append('_request_timeout') 6234 6235 params = locals() 6236 for key, val in iteritems(params['kwargs']): 6237 if key not in all_params: 6238 raise TypeError( 6239 "Got an unexpected keyword argument '%s'" 6240 " to method update_brand_resources_by_content_type" % key 6241 ) 6242 params[key] = val 6243 del params['kwargs'] 6244 # verify the required parameter 'account_id' is set 6245 if ('account_id' not in params) or (params['account_id'] is None): 6246 raise ValueError("Missing the required parameter `account_id` when calling `update_brand_resources_by_content_type`") 6247 # verify the required parameter 'brand_id' is set 6248 if ('brand_id' not in params) or (params['brand_id'] is None): 6249 raise ValueError("Missing the required parameter `brand_id` when calling `update_brand_resources_by_content_type`") 6250 # verify the required parameter 'resource_content_type' is set 6251 if ('resource_content_type' not in params) or (params['resource_content_type'] is None): 6252 raise ValueError("Missing the required parameter `resource_content_type` when calling `update_brand_resources_by_content_type`") 6253 # verify the required parameter 'file_xml' is set 6254 if ('file_xml' not in params) or (params['file_xml'] is None): 6255 raise ValueError("Missing the required parameter `file_xml` when calling `update_brand_resources_by_content_type`") 6256 6257 6258 collection_formats = {} 6259 6260 resource_path = '/v2.1/accounts/{accountId}/brands/{brandId}/resources/{resourceContentType}'.replace('{format}', 'json') 6261 path_params = {} 6262 if 'account_id' in params: 6263 path_params['accountId'] = params['account_id'] 6264 if 'brand_id' in params: 6265 path_params['brandId'] = params['brand_id'] 6266 if 'resource_content_type' in params: 6267 path_params['resourceContentType'] = params['resource_content_type'] 6268 6269 query_params = {} 6270 6271 header_params = {} 6272 6273 form_params = [] 6274 local_var_files = {} 6275 if 'file_xml' in params: 6276 local_var_files['file.xml'] = params['file_xml'] 6277 6278 body_params = None 6279 # HTTP header `Accept` 6280 header_params['Accept'] = self.api_client.\ 6281 select_header_accept(['application/json']) 6282 6283 # HTTP header `Content-Type` 6284 header_params['Content-Type'] = self.api_client.\ 6285 select_header_content_type(['multipart/form-data']) 6286 6287 # Authentication setting 6288 auth_settings = [] 6289 6290 return self.api_client.call_api(resource_path, 'PUT', 6291 path_params, 6292 query_params, 6293 header_params, 6294 body=body_params, 6295 post_params=form_params, 6296 files=local_var_files, 6297 response_type='BrandResources', 6298 auth_settings=auth_settings, 6299 callback=params.get('callback'), 6300 _return_http_data_only=params.get('_return_http_data_only'), 6301 _preload_content=params.get('_preload_content', True), 6302 _request_timeout=params.get('_request_timeout'), 6303 collection_formats=collection_formats)
Uploads a branding resource file.
This method updates a branding resource file. You pass in the new version of the resource file in the Content-Disposition header. Example: Content-Disposition: form-data; name="file"; filename="DocuSign_SigningResource_4328673.xml" Note: Branding for either signing or sending must be enabled for the account (canSelfBrandSend , canSelfBrandSign, or both of these account settings must be true). Important: Customizing resource files is an advanced branding configuration option which can significantly impact your account, and should be done only by someone with expertise in XML and HTML. The master resource files are subject to change without notice. If you customize your resource files, after each release, DocuSign recommends you review any changes and update your custom files as needed. When you upload a modified resource file, only the elements that differ from the master resource file are saved as your resource file. Similarly, when you download your resource files, only the modified elements are included in the file.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_brand_resources_by_content_type_with_http_info(account_id, brand_id, resource_content_type, file_xml, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID GUID. (required)
- str brand_id: The ID of the brand. (required)
- str resource_content_type: The type of brand resource file that you are updating. Valid values are: -
sending-signing-email-signing_captive(required) - file file_xml: Brand resource XML file. (required)
Returns
BrandResources If the method is called asynchronously, returns the request thread.
def
update_consumer_disclosure(self, account_id, lang_code, **kwargs)
6305 def update_consumer_disclosure(self, account_id, lang_code, **kwargs): 6306 """ 6307 Update Consumer Disclosure. 6308 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 6309 This method makes a synchronous HTTP request by default. To make an 6310 asynchronous HTTP request, please define a `callback` function 6311 to be invoked when receiving the response. 6312 >>> def callback_function(response): 6313 >>> pprint(response) 6314 >>> 6315 >>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function) 6316 6317 :param callback function: The callback function 6318 for asynchronous request. (optional) 6319 :param str account_id: The external account number (int) or account ID Guid. (required) 6320 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6321 :param str include_metadata: 6322 :param ConsumerDisclosure consumer_disclosure: 6323 :return: ConsumerDisclosure 6324 If the method is called asynchronously, 6325 returns the request thread. 6326 """ 6327 kwargs['_return_http_data_only'] = True 6328 if kwargs.get('callback'): 6329 return self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 6330 else: 6331 (data) = self.update_consumer_disclosure_with_http_info(account_id, lang_code, **kwargs) 6332 return data
Update Consumer Disclosure.
Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional langCode query parameter. Note: Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - accountEsignId: This property is read-only. - custom: The default value is false. Editing this property causes the default disclosure to switch to a custom disclosure. - esignAgreement: This property is read-only. - esignText: You cannot edit this property when custom is set to false. The API returns a 200 OK HTTP response, but does not update the esignText. - Metadata properties: These properties are read-only. Note: The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the custom property to true and customize the value for the eSignText property. You can also edit all of the other properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Note: When you use a custom disclosure, you can create versions of it in different signer languages and se the langCode parameter to specify the signer language version that you are updating. Important: When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Important: Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_consumer_disclosure(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
- str include_metadata:
- ConsumerDisclosure consumer_disclosure:
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs)
6334 def update_consumer_disclosure_with_http_info(self, account_id, lang_code, **kwargs): 6335 """ 6336 Update Consumer Disclosure. 6337 Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional `langCode` query parameter. **Note:** Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - `accountEsignId`: This property is read-only. - `custom`: The default value is **false.** Editing this property causes the default disclosure to switch to a custom disclosure. - `esignAgreement`: This property is read-only. - `esignText`: You cannot edit this property when `custom` is set to **false.** The API returns a 200 OK HTTP response, but does not update the `esignText`. - Metadata properties: These properties are read-only. **Note:** The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the `custom` property to **true** and customize the value for the `eSignText` property. You can also edit all of the other properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Note:** When you use a custom disclosure, you can create versions of it in different signer languages and se the `langCode` parameter to specify the signer language version that you are updating. **Important:** When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - `accountEsignId`: This property is read-only. - `esignAgreement`: This property is read-only. - Metadata properties: These properties are read-only. **Important:** Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. 6338 This method makes a synchronous HTTP request by default. To make an 6339 asynchronous HTTP request, please define a `callback` function 6340 to be invoked when receiving the response. 6341 >>> def callback_function(response): 6342 >>> pprint(response) 6343 >>> 6344 >>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function) 6345 6346 :param callback function: The callback function 6347 for asynchronous request. (optional) 6348 :param str account_id: The external account number (int) or account ID Guid. (required) 6349 :param str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are:Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required) 6350 :param str include_metadata: 6351 :param ConsumerDisclosure consumer_disclosure: 6352 :return: ConsumerDisclosure 6353 If the method is called asynchronously, 6354 returns the request thread. 6355 """ 6356 6357 all_params = ['account_id', 'lang_code', 'include_metadata', 'consumer_disclosure'] 6358 all_params.append('callback') 6359 all_params.append('_return_http_data_only') 6360 all_params.append('_preload_content') 6361 all_params.append('_request_timeout') 6362 6363 params = locals() 6364 for key, val in iteritems(params['kwargs']): 6365 if key not in all_params: 6366 raise TypeError( 6367 "Got an unexpected keyword argument '%s'" 6368 " to method update_consumer_disclosure" % key 6369 ) 6370 params[key] = val 6371 del params['kwargs'] 6372 # verify the required parameter 'account_id' is set 6373 if ('account_id' not in params) or (params['account_id'] is None): 6374 raise ValueError("Missing the required parameter `account_id` when calling `update_consumer_disclosure`") 6375 # verify the required parameter 'lang_code' is set 6376 if ('lang_code' not in params) or (params['lang_code'] is None): 6377 raise ValueError("Missing the required parameter `lang_code` when calling `update_consumer_disclosure`") 6378 6379 6380 collection_formats = {} 6381 6382 resource_path = '/v2.1/accounts/{accountId}/consumer_disclosure/{langCode}'.replace('{format}', 'json') 6383 path_params = {} 6384 if 'account_id' in params: 6385 path_params['accountId'] = params['account_id'] 6386 if 'lang_code' in params: 6387 path_params['langCode'] = params['lang_code'] 6388 6389 query_params = {} 6390 if 'include_metadata' in params: 6391 query_params['include_metadata'] = params['include_metadata'] 6392 6393 header_params = {} 6394 6395 form_params = [] 6396 local_var_files = {} 6397 6398 body_params = None 6399 if 'consumer_disclosure' in params: 6400 body_params = params['consumer_disclosure'] 6401 # HTTP header `Accept` 6402 header_params['Accept'] = self.api_client.\ 6403 select_header_accept(['application/json']) 6404 6405 # Authentication setting 6406 auth_settings = [] 6407 6408 return self.api_client.call_api(resource_path, 'PUT', 6409 path_params, 6410 query_params, 6411 header_params, 6412 body=body_params, 6413 post_params=form_params, 6414 files=local_var_files, 6415 response_type='ConsumerDisclosure', 6416 auth_settings=auth_settings, 6417 callback=params.get('callback'), 6418 _return_http_data_only=params.get('_return_http_data_only'), 6419 _preload_content=params.get('_preload_content', True), 6420 _request_timeout=params.get('_request_timeout'), 6421 collection_formats=collection_formats)
Update Consumer Disclosure.
Account administrators can use this method to perform the following tasks: - Customize values in the default disclosure. - Switch to a custom disclosure that uses your own text and HTML formatting. - Change values in your existing consumer disclosure. To specify the signer language version of the disclosure that you are updating, use the optional langCode query parameter. Note: Only account administrators can use this method. Each time you change the disclosure content, all unsigned recipients of outstanding documents will be required to accept a new version. ## Updating the default disclosure When you update the default disclosure, you can edit all properties except for the following ones: - accountEsignId: This property is read-only. - custom: The default value is false. Editing this property causes the default disclosure to switch to a custom disclosure. - esignAgreement: This property is read-only. - esignText: You cannot edit this property when custom is set to false. The API returns a 200 OK HTTP response, but does not update the esignText. - Metadata properties: These properties are read-only. Note: The text of the default disclosure is always in English. ## Switching to a custom disclosure To switch to a custom disclosure, set the custom property to true and customize the value for the eSignText property. You can also edit all of the other properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Note: When you use a custom disclosure, you can create versions of it in different signer languages and se the langCode parameter to specify the signer language version that you are updating. Important: When you switch from a default to a custom disclosure, note the following information: - You will not be able to return to using the default disclosure. - Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use. ## Updating a custom disclosure When you update a custom disclosure, you can update all of the properties except for the following ones: - accountEsignId: This property is read-only. - esignAgreement: This property is read-only. - Metadata properties: These properties are read-only. Important: Only the disclosure for the currently selected signer language is saved. DocuSign will not automatically translate your custom disclosure. You must create a disclosure for each language that your signers use.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_consumer_disclosure_with_http_info(account_id, lang_code, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str lang_code: The simple type enumeration the language used in the response. The supported languages, with the language value shown in parenthesis, are: Arabic (ar), Armenian (hy), Bulgarian (bg), Czech (cs), Chinese Simplified (zh_CN), Chinese Traditional (zh_TW), Croatian (hr), Danish (da), Dutch (nl), English US (en), English UK (en_GB), Estonian (et), Farsi (fa), Finnish (fi), French (fr), French Canada (fr_CA), German (de), Greek (el), Hebrew (he), Hindi (hi), Hungarian (hu), Bahasa Indonesia (id), Italian (it), Japanese (ja), Korean (ko), Latvian (lv), Lithuanian (lt), Bahasa Melayu (ms), Norwegian (no), Polish (pl), Portuguese (pt), Portuguese Brazil (pt_BR), Romanian (ro), Russian (ru), Serbian (sr), Slovak (sk), Slovenian (sl), Spanish (es),Spanish Latin America (es_MX), Swedish (sv), Thai (th), Turkish (tr), Ukrainian (uk) and Vietnamese (vi). Additionally, the value can be set to �browser� to automatically detect the browser language being used by the viewer and display the disclosure in that language. (required)
- str include_metadata:
- ConsumerDisclosure consumer_disclosure:
Returns
ConsumerDisclosure If the method is called asynchronously, returns the request thread.
def
update_custom_field(self, account_id, custom_field_id, **kwargs)
6423 def update_custom_field(self, account_id, custom_field_id, **kwargs): 6424 """ 6425 Updates an existing account custom field. 6426 This method updates an existing account custom field. 6427 This method makes a synchronous HTTP request by default. To make an 6428 asynchronous HTTP request, please define a `callback` function 6429 to be invoked when receiving the response. 6430 >>> def callback_function(response): 6431 >>> pprint(response) 6432 >>> 6433 >>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function) 6434 6435 :param callback function: The callback function 6436 for asynchronous request. (optional) 6437 :param str account_id: The external account number (int) or account ID Guid. (required) 6438 :param str custom_field_id: (required) 6439 :param str apply_to_templates: 6440 :param CustomField custom_field: 6441 :return: CustomFields 6442 If the method is called asynchronously, 6443 returns the request thread. 6444 """ 6445 kwargs['_return_http_data_only'] = True 6446 if kwargs.get('callback'): 6447 return self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 6448 else: 6449 (data) = self.update_custom_field_with_http_info(account_id, custom_field_id, **kwargs) 6450 return data
Updates an existing account custom field.
This method updates an existing account custom field.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_custom_field(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs)
6452 def update_custom_field_with_http_info(self, account_id, custom_field_id, **kwargs): 6453 """ 6454 Updates an existing account custom field. 6455 This method updates an existing account custom field. 6456 This method makes a synchronous HTTP request by default. To make an 6457 asynchronous HTTP request, please define a `callback` function 6458 to be invoked when receiving the response. 6459 >>> def callback_function(response): 6460 >>> pprint(response) 6461 >>> 6462 >>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function) 6463 6464 :param callback function: The callback function 6465 for asynchronous request. (optional) 6466 :param str account_id: The external account number (int) or account ID Guid. (required) 6467 :param str custom_field_id: (required) 6468 :param str apply_to_templates: 6469 :param CustomField custom_field: 6470 :return: CustomFields 6471 If the method is called asynchronously, 6472 returns the request thread. 6473 """ 6474 6475 all_params = ['account_id', 'custom_field_id', 'apply_to_templates', 'custom_field'] 6476 all_params.append('callback') 6477 all_params.append('_return_http_data_only') 6478 all_params.append('_preload_content') 6479 all_params.append('_request_timeout') 6480 6481 params = locals() 6482 for key, val in iteritems(params['kwargs']): 6483 if key not in all_params: 6484 raise TypeError( 6485 "Got an unexpected keyword argument '%s'" 6486 " to method update_custom_field" % key 6487 ) 6488 params[key] = val 6489 del params['kwargs'] 6490 # verify the required parameter 'account_id' is set 6491 if ('account_id' not in params) or (params['account_id'] is None): 6492 raise ValueError("Missing the required parameter `account_id` when calling `update_custom_field`") 6493 # verify the required parameter 'custom_field_id' is set 6494 if ('custom_field_id' not in params) or (params['custom_field_id'] is None): 6495 raise ValueError("Missing the required parameter `custom_field_id` when calling `update_custom_field`") 6496 6497 6498 collection_formats = {} 6499 6500 resource_path = '/v2.1/accounts/{accountId}/custom_fields/{customFieldId}'.replace('{format}', 'json') 6501 path_params = {} 6502 if 'account_id' in params: 6503 path_params['accountId'] = params['account_id'] 6504 if 'custom_field_id' in params: 6505 path_params['customFieldId'] = params['custom_field_id'] 6506 6507 query_params = {} 6508 if 'apply_to_templates' in params: 6509 query_params['apply_to_templates'] = params['apply_to_templates'] 6510 6511 header_params = {} 6512 6513 form_params = [] 6514 local_var_files = {} 6515 6516 body_params = None 6517 if 'custom_field' in params: 6518 body_params = params['custom_field'] 6519 # HTTP header `Accept` 6520 header_params['Accept'] = self.api_client.\ 6521 select_header_accept(['application/json']) 6522 6523 # Authentication setting 6524 auth_settings = [] 6525 6526 return self.api_client.call_api(resource_path, 'PUT', 6527 path_params, 6528 query_params, 6529 header_params, 6530 body=body_params, 6531 post_params=form_params, 6532 files=local_var_files, 6533 response_type='CustomFields', 6534 auth_settings=auth_settings, 6535 callback=params.get('callback'), 6536 _return_http_data_only=params.get('_return_http_data_only'), 6537 _preload_content=params.get('_preload_content', True), 6538 _request_timeout=params.get('_request_timeout'), 6539 collection_formats=collection_formats)
Updates an existing account custom field.
This method updates an existing account custom field.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_custom_field_with_http_info(account_id, custom_field_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str custom_field_id: (required)
- str apply_to_templates:
- CustomField custom_field:
Returns
CustomFields If the method is called asynchronously, returns the request thread.
def
update_e_note_configuration(self, account_id, **kwargs)
6541 def update_e_note_configuration(self, account_id, **kwargs): 6542 """ 6543 Updates configuration information for the eNote eOriginal integration. 6544 6545 This method makes a synchronous HTTP request by default. To make an 6546 asynchronous HTTP request, please define a `callback` function 6547 to be invoked when receiving the response. 6548 >>> def callback_function(response): 6549 >>> pprint(response) 6550 >>> 6551 >>> thread = api.update_e_note_configuration(account_id, callback=callback_function) 6552 6553 :param callback function: The callback function 6554 for asynchronous request. (optional) 6555 :param str account_id: The external account number (int) or account ID Guid. (required) 6556 :param ENoteConfiguration e_note_configuration: 6557 :return: ENoteConfiguration 6558 If the method is called asynchronously, 6559 returns the request thread. 6560 """ 6561 kwargs['_return_http_data_only'] = True 6562 if kwargs.get('callback'): 6563 return self.update_e_note_configuration_with_http_info(account_id, **kwargs) 6564 else: 6565 (data) = self.update_e_note_configuration_with_http_info(account_id, **kwargs) 6566 return data
Updates configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_e_note_configuration(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ENoteConfiguration e_note_configuration:
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
update_e_note_configuration_with_http_info(self, account_id, **kwargs)
6568 def update_e_note_configuration_with_http_info(self, account_id, **kwargs): 6569 """ 6570 Updates configuration information for the eNote eOriginal integration. 6571 6572 This method makes a synchronous HTTP request by default. To make an 6573 asynchronous HTTP request, please define a `callback` function 6574 to be invoked when receiving the response. 6575 >>> def callback_function(response): 6576 >>> pprint(response) 6577 >>> 6578 >>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function) 6579 6580 :param callback function: The callback function 6581 for asynchronous request. (optional) 6582 :param str account_id: The external account number (int) or account ID Guid. (required) 6583 :param ENoteConfiguration e_note_configuration: 6584 :return: ENoteConfiguration 6585 If the method is called asynchronously, 6586 returns the request thread. 6587 """ 6588 6589 all_params = ['account_id', 'e_note_configuration'] 6590 all_params.append('callback') 6591 all_params.append('_return_http_data_only') 6592 all_params.append('_preload_content') 6593 all_params.append('_request_timeout') 6594 6595 params = locals() 6596 for key, val in iteritems(params['kwargs']): 6597 if key not in all_params: 6598 raise TypeError( 6599 "Got an unexpected keyword argument '%s'" 6600 " to method update_e_note_configuration" % key 6601 ) 6602 params[key] = val 6603 del params['kwargs'] 6604 # verify the required parameter 'account_id' is set 6605 if ('account_id' not in params) or (params['account_id'] is None): 6606 raise ValueError("Missing the required parameter `account_id` when calling `update_e_note_configuration`") 6607 6608 6609 collection_formats = {} 6610 6611 resource_path = '/v2.1/accounts/{accountId}/settings/enote_configuration'.replace('{format}', 'json') 6612 path_params = {} 6613 if 'account_id' in params: 6614 path_params['accountId'] = params['account_id'] 6615 6616 query_params = {} 6617 6618 header_params = {} 6619 6620 form_params = [] 6621 local_var_files = {} 6622 6623 body_params = None 6624 if 'e_note_configuration' in params: 6625 body_params = params['e_note_configuration'] 6626 # HTTP header `Accept` 6627 header_params['Accept'] = self.api_client.\ 6628 select_header_accept(['application/json']) 6629 6630 # Authentication setting 6631 auth_settings = [] 6632 6633 return self.api_client.call_api(resource_path, 'PUT', 6634 path_params, 6635 query_params, 6636 header_params, 6637 body=body_params, 6638 post_params=form_params, 6639 files=local_var_files, 6640 response_type='ENoteConfiguration', 6641 auth_settings=auth_settings, 6642 callback=params.get('callback'), 6643 _return_http_data_only=params.get('_return_http_data_only'), 6644 _preload_content=params.get('_preload_content', True), 6645 _request_timeout=params.get('_request_timeout'), 6646 collection_formats=collection_formats)
Updates configuration information for the eNote eOriginal integration.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_e_note_configuration_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- ENoteConfiguration e_note_configuration:
Returns
ENoteConfiguration If the method is called asynchronously, returns the request thread.
def
update_envelope_purge_configuration(self, account_id, **kwargs)
6648 def update_envelope_purge_configuration(self, account_id, **kwargs): 6649 """ 6650 Updates envelope purge configuration. 6651 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 6652 This method makes a synchronous HTTP request by default. To make an 6653 asynchronous HTTP request, please define a `callback` function 6654 to be invoked when receiving the response. 6655 >>> def callback_function(response): 6656 >>> pprint(response) 6657 >>> 6658 >>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function) 6659 6660 :param callback function: The callback function 6661 for asynchronous request. (optional) 6662 :param str account_id: The external account number (int) or account ID Guid. (required) 6663 :param EnvelopePurgeConfiguration envelope_purge_configuration: 6664 :return: EnvelopePurgeConfiguration 6665 If the method is called asynchronously, 6666 returns the request thread. 6667 """ 6668 kwargs['_return_http_data_only'] = True 6669 if kwargs.get('callback'): 6670 return self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 6671 else: 6672 (data) = self.update_envelope_purge_configuration_with_http_info(account_id, **kwargs) 6673 return data
Updates envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method sets the envelope purge configuration for your account. Note: To use this method, you must be an account administrator. For more information, see Purge Envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_purge_configuration(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- EnvelopePurgeConfiguration envelope_purge_configuration:
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs)
6675 def update_envelope_purge_configuration_with_http_info(self, account_id, **kwargs): 6676 """ 6677 Updates envelope purge configuration. 6678 An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (`retentionDays`). This method sets the envelope purge configuration for your account. **Note:** To use this method, you must be an account administrator. For more information, see [Purge Envelopes](https://support.docusign.com/en/guides/ndse-user-guide-purge-envelopes). 6679 This method makes a synchronous HTTP request by default. To make an 6680 asynchronous HTTP request, please define a `callback` function 6681 to be invoked when receiving the response. 6682 >>> def callback_function(response): 6683 >>> pprint(response) 6684 >>> 6685 >>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function) 6686 6687 :param callback function: The callback function 6688 for asynchronous request. (optional) 6689 :param str account_id: The external account number (int) or account ID Guid. (required) 6690 :param EnvelopePurgeConfiguration envelope_purge_configuration: 6691 :return: EnvelopePurgeConfiguration 6692 If the method is called asynchronously, 6693 returns the request thread. 6694 """ 6695 6696 all_params = ['account_id', 'envelope_purge_configuration'] 6697 all_params.append('callback') 6698 all_params.append('_return_http_data_only') 6699 all_params.append('_preload_content') 6700 all_params.append('_request_timeout') 6701 6702 params = locals() 6703 for key, val in iteritems(params['kwargs']): 6704 if key not in all_params: 6705 raise TypeError( 6706 "Got an unexpected keyword argument '%s'" 6707 " to method update_envelope_purge_configuration" % key 6708 ) 6709 params[key] = val 6710 del params['kwargs'] 6711 # verify the required parameter 'account_id' is set 6712 if ('account_id' not in params) or (params['account_id'] is None): 6713 raise ValueError("Missing the required parameter `account_id` when calling `update_envelope_purge_configuration`") 6714 6715 6716 collection_formats = {} 6717 6718 resource_path = '/v2.1/accounts/{accountId}/settings/envelope_purge_configuration'.replace('{format}', 'json') 6719 path_params = {} 6720 if 'account_id' in params: 6721 path_params['accountId'] = params['account_id'] 6722 6723 query_params = {} 6724 6725 header_params = {} 6726 6727 form_params = [] 6728 local_var_files = {} 6729 6730 body_params = None 6731 if 'envelope_purge_configuration' in params: 6732 body_params = params['envelope_purge_configuration'] 6733 # HTTP header `Accept` 6734 header_params['Accept'] = self.api_client.\ 6735 select_header_accept(['application/json']) 6736 6737 # Authentication setting 6738 auth_settings = [] 6739 6740 return self.api_client.call_api(resource_path, 'PUT', 6741 path_params, 6742 query_params, 6743 header_params, 6744 body=body_params, 6745 post_params=form_params, 6746 files=local_var_files, 6747 response_type='EnvelopePurgeConfiguration', 6748 auth_settings=auth_settings, 6749 callback=params.get('callback'), 6750 _return_http_data_only=params.get('_return_http_data_only'), 6751 _preload_content=params.get('_preload_content', True), 6752 _request_timeout=params.get('_request_timeout'), 6753 collection_formats=collection_formats)
Updates envelope purge configuration.
An envelope purge configuration enables account administrators to permanently remove documents and their field data from completed and voided envelopes after a specified retention period (retentionDays). This method sets the envelope purge configuration for your account. Note: To use this method, you must be an account administrator. For more information, see Purge Envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_envelope_purge_configuration_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- EnvelopePurgeConfiguration envelope_purge_configuration:
Returns
EnvelopePurgeConfiguration If the method is called asynchronously, returns the request thread.
def
update_favorite_template(self, account_id, **kwargs)
6755 def update_favorite_template(self, account_id, **kwargs): 6756 """ 6757 Favorites a template 6758 6759 This method makes a synchronous HTTP request by default. To make an 6760 asynchronous HTTP request, please define a `callback` function 6761 to be invoked when receiving the response. 6762 >>> def callback_function(response): 6763 >>> pprint(response) 6764 >>> 6765 >>> thread = api.update_favorite_template(account_id, callback=callback_function) 6766 6767 :param callback function: The callback function 6768 for asynchronous request. (optional) 6769 :param str account_id: The external account number (int) or account ID Guid. (required) 6770 :param FavoriteTemplatesInfo favorite_templates_info: 6771 :return: FavoriteTemplatesInfo 6772 If the method is called asynchronously, 6773 returns the request thread. 6774 """ 6775 kwargs['_return_http_data_only'] = True 6776 if kwargs.get('callback'): 6777 return self.update_favorite_template_with_http_info(account_id, **kwargs) 6778 else: 6779 (data) = self.update_favorite_template_with_http_info(account_id, **kwargs) 6780 return data
Favorites a template
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_favorite_template(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
update_favorite_template_with_http_info(self, account_id, **kwargs)
6782 def update_favorite_template_with_http_info(self, account_id, **kwargs): 6783 """ 6784 Favorites a template 6785 6786 This method makes a synchronous HTTP request by default. To make an 6787 asynchronous HTTP request, please define a `callback` function 6788 to be invoked when receiving the response. 6789 >>> def callback_function(response): 6790 >>> pprint(response) 6791 >>> 6792 >>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function) 6793 6794 :param callback function: The callback function 6795 for asynchronous request. (optional) 6796 :param str account_id: The external account number (int) or account ID Guid. (required) 6797 :param FavoriteTemplatesInfo favorite_templates_info: 6798 :return: FavoriteTemplatesInfo 6799 If the method is called asynchronously, 6800 returns the request thread. 6801 """ 6802 6803 all_params = ['account_id', 'favorite_templates_info'] 6804 all_params.append('callback') 6805 all_params.append('_return_http_data_only') 6806 all_params.append('_preload_content') 6807 all_params.append('_request_timeout') 6808 6809 params = locals() 6810 for key, val in iteritems(params['kwargs']): 6811 if key not in all_params: 6812 raise TypeError( 6813 "Got an unexpected keyword argument '%s'" 6814 " to method update_favorite_template" % key 6815 ) 6816 params[key] = val 6817 del params['kwargs'] 6818 # verify the required parameter 'account_id' is set 6819 if ('account_id' not in params) or (params['account_id'] is None): 6820 raise ValueError("Missing the required parameter `account_id` when calling `update_favorite_template`") 6821 6822 6823 collection_formats = {} 6824 6825 resource_path = '/v2.1/accounts/{accountId}/favorite_templates'.replace('{format}', 'json') 6826 path_params = {} 6827 if 'account_id' in params: 6828 path_params['accountId'] = params['account_id'] 6829 6830 query_params = {} 6831 6832 header_params = {} 6833 6834 form_params = [] 6835 local_var_files = {} 6836 6837 body_params = None 6838 if 'favorite_templates_info' in params: 6839 body_params = params['favorite_templates_info'] 6840 # HTTP header `Accept` 6841 header_params['Accept'] = self.api_client.\ 6842 select_header_accept(['application/json']) 6843 6844 # Authentication setting 6845 auth_settings = [] 6846 6847 return self.api_client.call_api(resource_path, 'PUT', 6848 path_params, 6849 query_params, 6850 header_params, 6851 body=body_params, 6852 post_params=form_params, 6853 files=local_var_files, 6854 response_type='FavoriteTemplatesInfo', 6855 auth_settings=auth_settings, 6856 callback=params.get('callback'), 6857 _return_http_data_only=params.get('_return_http_data_only'), 6858 _preload_content=params.get('_preload_content', True), 6859 _request_timeout=params.get('_request_timeout'), 6860 collection_formats=collection_formats)
Favorites a template
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_favorite_template_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- FavoriteTemplatesInfo favorite_templates_info:
Returns
FavoriteTemplatesInfo If the method is called asynchronously, returns the request thread.
def
update_notification_defaults(self, account_id, **kwargs)
6862 def update_notification_defaults(self, account_id, **kwargs): 6863 """ 6864 Updates default user level settings for a specified account 6865 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 6866 This method makes a synchronous HTTP request by default. To make an 6867 asynchronous HTTP request, please define a `callback` function 6868 to be invoked when receiving the response. 6869 >>> def callback_function(response): 6870 >>> pprint(response) 6871 >>> 6872 >>> thread = api.update_notification_defaults(account_id, callback=callback_function) 6873 6874 :param callback function: The callback function 6875 for asynchronous request. (optional) 6876 :param str account_id: The external account number (int) or account ID Guid. (required) 6877 :param NotificationDefaults notification_defaults: 6878 :return: NotificationDefaults 6879 If the method is called asynchronously, 6880 returns the request thread. 6881 """ 6882 kwargs['_return_http_data_only'] = True 6883 if kwargs.get('callback'): 6884 return self.update_notification_defaults_with_http_info(account_id, **kwargs) 6885 else: 6886 (data) = self.update_notification_defaults_with_http_info(account_id, **kwargs) 6887 return data
Updates default user level settings for a specified account
This method changes the default settings for the email notifications that signers and senders receive about envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_notification_defaults(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- NotificationDefaults notification_defaults:
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
update_notification_defaults_with_http_info(self, account_id, **kwargs)
6889 def update_notification_defaults_with_http_info(self, account_id, **kwargs): 6890 """ 6891 Updates default user level settings for a specified account 6892 This method changes the default settings for the email notifications that signers and senders receive about envelopes. 6893 This method makes a synchronous HTTP request by default. To make an 6894 asynchronous HTTP request, please define a `callback` function 6895 to be invoked when receiving the response. 6896 >>> def callback_function(response): 6897 >>> pprint(response) 6898 >>> 6899 >>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function) 6900 6901 :param callback function: The callback function 6902 for asynchronous request. (optional) 6903 :param str account_id: The external account number (int) or account ID Guid. (required) 6904 :param NotificationDefaults notification_defaults: 6905 :return: NotificationDefaults 6906 If the method is called asynchronously, 6907 returns the request thread. 6908 """ 6909 6910 all_params = ['account_id', 'notification_defaults'] 6911 all_params.append('callback') 6912 all_params.append('_return_http_data_only') 6913 all_params.append('_preload_content') 6914 all_params.append('_request_timeout') 6915 6916 params = locals() 6917 for key, val in iteritems(params['kwargs']): 6918 if key not in all_params: 6919 raise TypeError( 6920 "Got an unexpected keyword argument '%s'" 6921 " to method update_notification_defaults" % key 6922 ) 6923 params[key] = val 6924 del params['kwargs'] 6925 # verify the required parameter 'account_id' is set 6926 if ('account_id' not in params) or (params['account_id'] is None): 6927 raise ValueError("Missing the required parameter `account_id` when calling `update_notification_defaults`") 6928 6929 6930 collection_formats = {} 6931 6932 resource_path = '/v2.1/accounts/{accountId}/settings/notification_defaults'.replace('{format}', 'json') 6933 path_params = {} 6934 if 'account_id' in params: 6935 path_params['accountId'] = params['account_id'] 6936 6937 query_params = {} 6938 6939 header_params = {} 6940 6941 form_params = [] 6942 local_var_files = {} 6943 6944 body_params = None 6945 if 'notification_defaults' in params: 6946 body_params = params['notification_defaults'] 6947 # HTTP header `Accept` 6948 header_params['Accept'] = self.api_client.\ 6949 select_header_accept(['application/json']) 6950 6951 # Authentication setting 6952 auth_settings = [] 6953 6954 return self.api_client.call_api(resource_path, 'PUT', 6955 path_params, 6956 query_params, 6957 header_params, 6958 body=body_params, 6959 post_params=form_params, 6960 files=local_var_files, 6961 response_type='NotificationDefaults', 6962 auth_settings=auth_settings, 6963 callback=params.get('callback'), 6964 _return_http_data_only=params.get('_return_http_data_only'), 6965 _preload_content=params.get('_preload_content', True), 6966 _request_timeout=params.get('_request_timeout'), 6967 collection_formats=collection_formats)
Updates default user level settings for a specified account
This method changes the default settings for the email notifications that signers and senders receive about envelopes.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_notification_defaults_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- NotificationDefaults notification_defaults:
Returns
NotificationDefaults If the method is called asynchronously, returns the request thread.
def
update_password_rules(self, account_id, **kwargs)
6969 def update_password_rules(self, account_id, **kwargs): 6970 """ 6971 Update the password rules 6972 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 6973 This method makes a synchronous HTTP request by default. To make an 6974 asynchronous HTTP request, please define a `callback` function 6975 to be invoked when receiving the response. 6976 >>> def callback_function(response): 6977 >>> pprint(response) 6978 >>> 6979 >>> thread = api.update_password_rules(account_id, callback=callback_function) 6980 6981 :param callback function: The callback function 6982 for asynchronous request. (optional) 6983 :param str account_id: The external account number (int) or account ID Guid. (required) 6984 :param AccountPasswordRules account_password_rules: 6985 :return: AccountPasswordRules 6986 If the method is called asynchronously, 6987 returns the request thread. 6988 """ 6989 kwargs['_return_http_data_only'] = True 6990 if kwargs.get('callback'): 6991 return self.update_password_rules_with_http_info(account_id, **kwargs) 6992 else: 6993 (data) = self.update_password_rules_with_http_info(account_id, **kwargs) 6994 return data
Update the password rules
This method updates the password rules for an account. Note: To update the password rules for an account, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_password_rules(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- AccountPasswordRules account_password_rules:
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
update_password_rules_with_http_info(self, account_id, **kwargs)
6996 def update_password_rules_with_http_info(self, account_id, **kwargs): 6997 """ 6998 Update the password rules 6999 This method updates the password rules for an account. **Note:** To update the password rules for an account, you must be an account administrator. 7000 This method makes a synchronous HTTP request by default. To make an 7001 asynchronous HTTP request, please define a `callback` function 7002 to be invoked when receiving the response. 7003 >>> def callback_function(response): 7004 >>> pprint(response) 7005 >>> 7006 >>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function) 7007 7008 :param callback function: The callback function 7009 for asynchronous request. (optional) 7010 :param str account_id: The external account number (int) or account ID Guid. (required) 7011 :param AccountPasswordRules account_password_rules: 7012 :return: AccountPasswordRules 7013 If the method is called asynchronously, 7014 returns the request thread. 7015 """ 7016 7017 all_params = ['account_id', 'account_password_rules'] 7018 all_params.append('callback') 7019 all_params.append('_return_http_data_only') 7020 all_params.append('_preload_content') 7021 all_params.append('_request_timeout') 7022 7023 params = locals() 7024 for key, val in iteritems(params['kwargs']): 7025 if key not in all_params: 7026 raise TypeError( 7027 "Got an unexpected keyword argument '%s'" 7028 " to method update_password_rules" % key 7029 ) 7030 params[key] = val 7031 del params['kwargs'] 7032 # verify the required parameter 'account_id' is set 7033 if ('account_id' not in params) or (params['account_id'] is None): 7034 raise ValueError("Missing the required parameter `account_id` when calling `update_password_rules`") 7035 7036 7037 collection_formats = {} 7038 7039 resource_path = '/v2.1/accounts/{accountId}/settings/password_rules'.replace('{format}', 'json') 7040 path_params = {} 7041 if 'account_id' in params: 7042 path_params['accountId'] = params['account_id'] 7043 7044 query_params = {} 7045 7046 header_params = {} 7047 7048 form_params = [] 7049 local_var_files = {} 7050 7051 body_params = None 7052 if 'account_password_rules' in params: 7053 body_params = params['account_password_rules'] 7054 # HTTP header `Accept` 7055 header_params['Accept'] = self.api_client.\ 7056 select_header_accept(['application/json']) 7057 7058 # Authentication setting 7059 auth_settings = [] 7060 7061 return self.api_client.call_api(resource_path, 'PUT', 7062 path_params, 7063 query_params, 7064 header_params, 7065 body=body_params, 7066 post_params=form_params, 7067 files=local_var_files, 7068 response_type='AccountPasswordRules', 7069 auth_settings=auth_settings, 7070 callback=params.get('callback'), 7071 _return_http_data_only=params.get('_return_http_data_only'), 7072 _preload_content=params.get('_preload_content', True), 7073 _request_timeout=params.get('_request_timeout'), 7074 collection_formats=collection_formats)
Update the password rules
This method updates the password rules for an account. Note: To update the password rules for an account, you must be an account administrator.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_password_rules_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- AccountPasswordRules account_password_rules:
Returns
AccountPasswordRules If the method is called asynchronously, returns the request thread.
def
update_permission_profile(self, account_id, permission_profile_id, **kwargs)
7076 def update_permission_profile(self, account_id, permission_profile_id, **kwargs): 7077 """ 7078 Updates a permission profile within the specified account. 7079 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7080 This method makes a synchronous HTTP request by default. To make an 7081 asynchronous HTTP request, please define a `callback` function 7082 to be invoked when receiving the response. 7083 >>> def callback_function(response): 7084 >>> pprint(response) 7085 >>> 7086 >>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function) 7087 7088 :param callback function: The callback function 7089 for asynchronous request. (optional) 7090 :param str account_id: The external account number (int) or account ID Guid. (required) 7091 :param str permission_profile_id: (required) 7092 :param str include: 7093 :param PermissionProfile permission_profile: 7094 :return: PermissionProfile 7095 If the method is called asynchronously, 7096 returns the request thread. 7097 """ 7098 kwargs['_return_http_data_only'] = True 7099 if kwargs.get('callback'): 7100 return self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7101 else: 7102 (data) = self.update_permission_profile_with_http_info(account_id, permission_profile_id, **kwargs) 7103 return data
Updates a permission profile within the specified account.
This method updates an account permission profile. ### Related topics - How to update individual permission settings
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_permission_profile(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs)
7105 def update_permission_profile_with_http_info(self, account_id, permission_profile_id, **kwargs): 7106 """ 7107 Updates a permission profile within the specified account. 7108 This method updates an account permission profile. ### Related topics - [How to update individual permission settings](/docs/esign-rest-api/how-to/permission-profile-updating/) 7109 This method makes a synchronous HTTP request by default. To make an 7110 asynchronous HTTP request, please define a `callback` function 7111 to be invoked when receiving the response. 7112 >>> def callback_function(response): 7113 >>> pprint(response) 7114 >>> 7115 >>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function) 7116 7117 :param callback function: The callback function 7118 for asynchronous request. (optional) 7119 :param str account_id: The external account number (int) or account ID Guid. (required) 7120 :param str permission_profile_id: (required) 7121 :param str include: 7122 :param PermissionProfile permission_profile: 7123 :return: PermissionProfile 7124 If the method is called asynchronously, 7125 returns the request thread. 7126 """ 7127 7128 all_params = ['account_id', 'permission_profile_id', 'include', 'permission_profile'] 7129 all_params.append('callback') 7130 all_params.append('_return_http_data_only') 7131 all_params.append('_preload_content') 7132 all_params.append('_request_timeout') 7133 7134 params = locals() 7135 for key, val in iteritems(params['kwargs']): 7136 if key not in all_params: 7137 raise TypeError( 7138 "Got an unexpected keyword argument '%s'" 7139 " to method update_permission_profile" % key 7140 ) 7141 params[key] = val 7142 del params['kwargs'] 7143 # verify the required parameter 'account_id' is set 7144 if ('account_id' not in params) or (params['account_id'] is None): 7145 raise ValueError("Missing the required parameter `account_id` when calling `update_permission_profile`") 7146 # verify the required parameter 'permission_profile_id' is set 7147 if ('permission_profile_id' not in params) or (params['permission_profile_id'] is None): 7148 raise ValueError("Missing the required parameter `permission_profile_id` when calling `update_permission_profile`") 7149 7150 7151 collection_formats = {} 7152 7153 resource_path = '/v2.1/accounts/{accountId}/permission_profiles/{permissionProfileId}'.replace('{format}', 'json') 7154 path_params = {} 7155 if 'account_id' in params: 7156 path_params['accountId'] = params['account_id'] 7157 if 'permission_profile_id' in params: 7158 path_params['permissionProfileId'] = params['permission_profile_id'] 7159 7160 query_params = {} 7161 if 'include' in params: 7162 query_params['include'] = params['include'] 7163 7164 header_params = {} 7165 7166 form_params = [] 7167 local_var_files = {} 7168 7169 body_params = None 7170 if 'permission_profile' in params: 7171 body_params = params['permission_profile'] 7172 # HTTP header `Accept` 7173 header_params['Accept'] = self.api_client.\ 7174 select_header_accept(['application/json']) 7175 7176 # Authentication setting 7177 auth_settings = [] 7178 7179 return self.api_client.call_api(resource_path, 'PUT', 7180 path_params, 7181 query_params, 7182 header_params, 7183 body=body_params, 7184 post_params=form_params, 7185 files=local_var_files, 7186 response_type='PermissionProfile', 7187 auth_settings=auth_settings, 7188 callback=params.get('callback'), 7189 _return_http_data_only=params.get('_return_http_data_only'), 7190 _preload_content=params.get('_preload_content', True), 7191 _request_timeout=params.get('_request_timeout'), 7192 collection_formats=collection_formats)
Updates a permission profile within the specified account.
This method updates an account permission profile. ### Related topics - How to update individual permission settings
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_permission_profile_with_http_info(account_id, permission_profile_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- str permission_profile_id: (required)
- str include:
- PermissionProfile permission_profile:
Returns
PermissionProfile If the method is called asynchronously, returns the request thread.
def
update_settings(self, account_id, **kwargs)
7194 def update_settings(self, account_id, **kwargs): 7195 """ 7196 Updates the account settings for an account. 7197 Updates the account settings for the specified account. 7198 This method makes a synchronous HTTP request by default. To make an 7199 asynchronous HTTP request, please define a `callback` function 7200 to be invoked when receiving the response. 7201 >>> def callback_function(response): 7202 >>> pprint(response) 7203 >>> 7204 >>> thread = api.update_settings(account_id, callback=callback_function) 7205 7206 :param callback function: The callback function 7207 for asynchronous request. (optional) 7208 :param str account_id: The external account number (int) or account ID Guid. (required) 7209 :param AccountSettingsInformation account_settings_information: 7210 :return: None 7211 If the method is called asynchronously, 7212 returns the request thread. 7213 """ 7214 kwargs['_return_http_data_only'] = True 7215 if kwargs.get('callback'): 7216 return self.update_settings_with_http_info(account_id, **kwargs) 7217 else: 7218 (data) = self.update_settings_with_http_info(account_id, **kwargs) 7219 return data
Updates the account settings for an account.
Updates the account settings for the specified account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_settings(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- AccountSettingsInformation account_settings_information:
Returns
None If the method is called asynchronously, returns the request thread.
def
update_settings_with_http_info(self, account_id, **kwargs)
7221 def update_settings_with_http_info(self, account_id, **kwargs): 7222 """ 7223 Updates the account settings for an account. 7224 Updates the account settings for the specified account. 7225 This method makes a synchronous HTTP request by default. To make an 7226 asynchronous HTTP request, please define a `callback` function 7227 to be invoked when receiving the response. 7228 >>> def callback_function(response): 7229 >>> pprint(response) 7230 >>> 7231 >>> thread = api.update_settings_with_http_info(account_id, callback=callback_function) 7232 7233 :param callback function: The callback function 7234 for asynchronous request. (optional) 7235 :param str account_id: The external account number (int) or account ID Guid. (required) 7236 :param AccountSettingsInformation account_settings_information: 7237 :return: None 7238 If the method is called asynchronously, 7239 returns the request thread. 7240 """ 7241 7242 all_params = ['account_id', 'account_settings_information'] 7243 all_params.append('callback') 7244 all_params.append('_return_http_data_only') 7245 all_params.append('_preload_content') 7246 all_params.append('_request_timeout') 7247 7248 params = locals() 7249 for key, val in iteritems(params['kwargs']): 7250 if key not in all_params: 7251 raise TypeError( 7252 "Got an unexpected keyword argument '%s'" 7253 " to method update_settings" % key 7254 ) 7255 params[key] = val 7256 del params['kwargs'] 7257 # verify the required parameter 'account_id' is set 7258 if ('account_id' not in params) or (params['account_id'] is None): 7259 raise ValueError("Missing the required parameter `account_id` when calling `update_settings`") 7260 7261 7262 collection_formats = {} 7263 7264 resource_path = '/v2.1/accounts/{accountId}/settings'.replace('{format}', 'json') 7265 path_params = {} 7266 if 'account_id' in params: 7267 path_params['accountId'] = params['account_id'] 7268 7269 query_params = {} 7270 7271 header_params = {} 7272 7273 form_params = [] 7274 local_var_files = {} 7275 7276 body_params = None 7277 if 'account_settings_information' in params: 7278 body_params = params['account_settings_information'] 7279 # HTTP header `Accept` 7280 header_params['Accept'] = self.api_client.\ 7281 select_header_accept(['application/json']) 7282 7283 # Authentication setting 7284 auth_settings = [] 7285 7286 return self.api_client.call_api(resource_path, 'PUT', 7287 path_params, 7288 query_params, 7289 header_params, 7290 body=body_params, 7291 post_params=form_params, 7292 files=local_var_files, 7293 response_type=None, 7294 auth_settings=auth_settings, 7295 callback=params.get('callback'), 7296 _return_http_data_only=params.get('_return_http_data_only'), 7297 _preload_content=params.get('_preload_content', True), 7298 _request_timeout=params.get('_request_timeout'), 7299 collection_formats=collection_formats)
Updates the account settings for an account.
Updates the account settings for the specified account.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_settings_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- AccountSettingsInformation account_settings_information:
Returns
None If the method is called asynchronously, returns the request thread.
def
update_watermark(self, account_id, **kwargs)
7420 def update_watermark(self, account_id, **kwargs): 7421 """ 7422 Update watermark information. 7423 7424 This method makes a synchronous HTTP request by default. To make an 7425 asynchronous HTTP request, please define a `callback` function 7426 to be invoked when receiving the response. 7427 >>> def callback_function(response): 7428 >>> pprint(response) 7429 >>> 7430 >>> thread = api.update_watermark(account_id, callback=callback_function) 7431 7432 :param callback function: The callback function 7433 for asynchronous request. (optional) 7434 :param str account_id: The external account number (int) or account ID Guid. (required) 7435 :param Watermark watermark: 7436 :return: Watermark 7437 If the method is called asynchronously, 7438 returns the request thread. 7439 """ 7440 kwargs['_return_http_data_only'] = True 7441 if kwargs.get('callback'): 7442 return self.update_watermark_with_http_info(account_id, **kwargs) 7443 else: 7444 (data) = self.update_watermark_with_http_info(account_id, **kwargs) 7445 return data
Update watermark information.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_watermark(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.
def
update_watermark_with_http_info(self, account_id, **kwargs)
7447 def update_watermark_with_http_info(self, account_id, **kwargs): 7448 """ 7449 Update watermark information. 7450 7451 This method makes a synchronous HTTP request by default. To make an 7452 asynchronous HTTP request, please define a `callback` function 7453 to be invoked when receiving the response. 7454 >>> def callback_function(response): 7455 >>> pprint(response) 7456 >>> 7457 >>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function) 7458 7459 :param callback function: The callback function 7460 for asynchronous request. (optional) 7461 :param str account_id: The external account number (int) or account ID Guid. (required) 7462 :param Watermark watermark: 7463 :return: Watermark 7464 If the method is called asynchronously, 7465 returns the request thread. 7466 """ 7467 7468 all_params = ['account_id', 'watermark'] 7469 all_params.append('callback') 7470 all_params.append('_return_http_data_only') 7471 all_params.append('_preload_content') 7472 all_params.append('_request_timeout') 7473 7474 params = locals() 7475 for key, val in iteritems(params['kwargs']): 7476 if key not in all_params: 7477 raise TypeError( 7478 "Got an unexpected keyword argument '%s'" 7479 " to method update_watermark" % key 7480 ) 7481 params[key] = val 7482 del params['kwargs'] 7483 # verify the required parameter 'account_id' is set 7484 if ('account_id' not in params) or (params['account_id'] is None): 7485 raise ValueError("Missing the required parameter `account_id` when calling `update_watermark`") 7486 7487 7488 collection_formats = {} 7489 7490 resource_path = '/v2.1/accounts/{accountId}/watermark'.replace('{format}', 'json') 7491 path_params = {} 7492 if 'account_id' in params: 7493 path_params['accountId'] = params['account_id'] 7494 7495 query_params = {} 7496 7497 header_params = {} 7498 7499 form_params = [] 7500 local_var_files = {} 7501 7502 body_params = None 7503 if 'watermark' in params: 7504 body_params = params['watermark'] 7505 # HTTP header `Accept` 7506 header_params['Accept'] = self.api_client.\ 7507 select_header_accept(['application/json']) 7508 7509 # Authentication setting 7510 auth_settings = [] 7511 7512 return self.api_client.call_api(resource_path, 'PUT', 7513 path_params, 7514 query_params, 7515 header_params, 7516 body=body_params, 7517 post_params=form_params, 7518 files=local_var_files, 7519 response_type='Watermark', 7520 auth_settings=auth_settings, 7521 callback=params.get('callback'), 7522 _return_http_data_only=params.get('_return_http_data_only'), 7523 _preload_content=params.get('_preload_content', True), 7524 _request_timeout=params.get('_request_timeout'), 7525 collection_formats=collection_formats)
Update watermark information.
This method makes a synchronous HTTP request by default. To make an
asynchronous HTTP request, please define a callback function
to be invoked when receiving the response.
>>> def callback_function(response):
>>> pprint(response)
>>>
>>> thread = api.update_watermark_with_http_info(account_id, callback=callback_function)
Parameters
- callback function: The callback function for asynchronous request. (optional)
- str account_id: The external account number (int) or account ID Guid. (required)
- Watermark watermark:
Returns
Watermark If the method is called asynchronously, returns the request thread.